github_api 0.1.0.pre → 0.1.0

data/README.rdoc

@@ -8,11 +8,11 @@ Supports all the API methods(nearly 200). It's build in a modular way, that is,
 
 Grab the gem by issuing
 
-  gem install github-api
+  gem install github_api --pre
 
 or in your Gemfile
 
-  gem 'github-api'
+  gem "github_api", "~> 0.1.0.pre"
 
 == Usage
 
@@ -69,7 +69,7 @@ Main API methods are grouped into the following classes that can be instantiated
   Github::Repos
   Github::Users
 
-Some parts of GitHub API v3 require you to be autheticated, for instance the following are examples of API only for the authenticated user
+Some parts of GitHub API v3 require you to be autheticated, for instance the following are examples of APIs only for the authenticated user
 
   Github::Users::Emails
   Github::Users::Keys
@@ -83,6 +83,22 @@ All method calls form ruby like sentences and allow for intuitive api navigation
 For specification on all available methods go to http://developer.github.com/v3/ or
 read the rdoc, all methods are documented there with examples of usage.
 
+== Inputs
+
+Some API methods apart from required parameters such as username, repository name
+or organisation name, allow you to switch the way the data is returned to you, for instance
+
+  @github = Github.new
+  @github.git_data.tree 'peter-murach', 'github', 'c18647b75d72f19c1e0cc8af031e5d833b7f12ea' # => gets a tree
+
+  @github.git_data.tree 'peter-murach', 'github', 'c18647b75d72f19c1e0cc8af031e5d833b7f12ea', :recursive => true # => gets a whole tree recursively
+
+  by passing a block you can iterate over the file tree
+
+  @github.git_data.tree 'peter-murach', 'github', 'c18647b75d72f19c1e0cc8af031e5d833b7f12ea', :recursive => true do |file|
+    puts file.path
+  end
+
 == MIME Types
 
 Provides support for the following mime types
@@ -133,6 +149,8 @@ Query requests instead of http responses return boolean values
 
 == Caching
 
+Each call by default is not going to be cached. In order to set the inmemory cache do...
+
 == TODO
 
 * Add support for mime types

data/lib/github_api/api.rb

@@ -78,6 +78,7 @@ module Github
       { 'user' => self.user, 'repo' => self.repo }.merge!(params)
     end
 
+    # Turns any keys from nested hashes including nested arrays into strings
     def _normalize_params_keys(params)
       case params
       when Hash
@@ -86,9 +87,11 @@ module Github
           _normalize_params_keys(params[k.to_s])
         end
       when Array
-        params.map! { |el| el.to_s }
+        params.map! do |el|
+          _normalize_params_keys(el)
+        end
       else
-        params
+        params.to_s
       end
       return params
     end
@@ -97,6 +100,23 @@ module Github
       params.reject! { |k,v| !keys.include? k }
     end
 
+    def _hash_traverse(hash, &block)
+      hash.each do |key, val|
+        block.call(key)
+        case val
+        when Hash
+          val.keys.each do |k|
+            _hash_traverse(val, &block)
+          end
+        when Array
+          val.each do |item|
+            _hash_traverse(item, &block)
+          end
+        end
+      end
+      return hash
+    end
+
     def _validate_params_values(options, params)
       params.each do |k, v|
         next unless options.keys.include?(k)

data/lib/github_api/client.rb

@@ -7,7 +7,10 @@ module Github
       @gists ||= Github::Gists.new(options)
     end
 
-    def git_data(options)
+    # The Git Database API gives you access to read and write raw Git objects
+    # to your Git database on GitHub and to list and update your references
+    # (branch heads and tags).
+    def git_data(options = {})
       @git_data ||= Github::GitData.new(options)
     end
 
@@ -27,6 +30,8 @@ module Github
       @repos ||= Github::Repos.new(options)
     end
 
+    # Many of the resources on the users API provide a shortcut for getting 
+    # information about the currently authenticated user.
     def users(options = {})
       @users ||= Github::Users.new(options)
     end

data/lib/github_api/configuration.rb

@@ -30,7 +30,7 @@ module Github
     DEFAULT_OAUTH_TOKEN = nil
 
     # The endpoint used to connect to GitHub if none is set
-    DEFAULT_ENDPOINT = 'https://api.github.com/'.freeze
+    DEFAULT_ENDPOINT = 'https://api.github.com'.freeze
 
     # The value sent in the http header for 'User-Agent' if none is set
     DEFAULT_USER_AGENT = "Github Ruby Gem #{Github::VERSION::STRING}".freeze

data/lib/github_api/git_data/blobs.rb

@@ -2,8 +2,50 @@
 
 module Github
   class GitData
+    # Since blobs can be any arbitrary binary data, the input and responses for
+    # the blob api takes an encoding parameter that can be either utf-8 or base64.
+    # If your data cannot be losslessly sent as a UTF-8 string, you can base64 encode it.
     module Blobs
 
+      VALID_BLOB_PARAM_NAMES = %w[ content encoding ].freeze
+
+      # Get a blob
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.blob 'user-name', 'repo-name', 'sha'
+      #
+      def blob(user_name, repo_name, sha, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of sha
+        _normalize_params_keys(params)
+
+        get("/repos/#{user}/#{repo}/git/blobs/#{sha}", params)
+      end
+
+      # Create a blob
+      #
+      # = Inputs
+      # * <tt>:content</tt> - String of content
+      # * <tt>:encoding</tt> - String containing encoding<tt>utf-8</tt> or <tt>base64</tt>
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.create_blob 'user-name', 'repo-name',
+      #    "content" => "Content of the blob",
+      #    "encoding" => "utf-8"
+      #
+      def create_blob(user_name, 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(VALID_BLOB_PARAM_NAMES, params)
+
+        raise ArgumentError, "Required params are: #{VALID_BLOB_PARAM_NAMES.join(', ')}" unless _validate_inputs(VALID_BLOB_PARAM_NAMES, params)
+
+        post("/repos/#{user}/#{repo}/git/blobs", params)
+      end
+
     end # Blobs
   end # GitData
 end # Github

data/lib/github_api/git_data/commits.rb

@@ -4,6 +4,75 @@ module Github
   class GitData
     module Commits
 
+      VALID_COMMIT_PARAM_NAMES = %w[
+        message
+        tree
+        parents
+        author
+        committer
+        name
+        email
+        date
+      ].freeze
+
+      # Get a commit
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.commit 'user-name', 'repo-name', 'sha'
+      #
+      def commit(user_name, repo_name, sha, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of sha
+        _normalize_params_keys(params)
+
+        get("/repos/#{user}/#{repo}/git/commits/#{sha}", params)
+      end
+
+      # Create a commit
+      #
+      # = Parameters
+      # * <tt>message</tt> - String of the commit message
+      # * <tt>tree</tt> - String of the SHA of the tree object this commit points to
+      # * <tt>parents</tt> - Array of the SHAs of the commits that were the parents of this commit. If omitted or empty, the commit will be written as a root commit. For a single parent, an array of one SHA should be provided, for a merge commit, an array of more than one should be provided.
+      #
+      # = Optional Parameters
+      #
+      # The committer section is optional and will be filled with the author data if omitted. If the author section is omitted, it will be filled in with the authenticated users information and the current date.
+      #
+      # * author.name:: String of the name of the author of the commit
+      # * author.email:: String of the email of the author of the commit
+      # * author.date:: Timestamp of when this commit was authored
+      # * committer.name:: String of the name of the committer of the commit
+      # * committer.email:: String of the email of the committer of the commit
+      # * committer.date:: Timestamp of when this commit was committed
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.create_commit 'user-name', 'repo-name',
+      #    "message": "my commit message",
+      #    "author": {
+      #      "name": "Scott Chacon",
+      #      "email": "schacon@gmail.com",
+      #      "date": "2008-07-09T16:13:30+12:00"
+      #    },
+      #   "parents": [
+      #      "7d1b31e74ee336d15cbd21741bc88a537ed063a0"
+      #    ],
+      #    "tree": "827efc6d56897b048c772eb4087f854f46256132"]
+      #
+      def create_commit(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(VALID_COMMIT_PARAM_NAMES, params)
+
+        raise ArgumentError, "Required params are: message, tree, parents" unless _validate_inputs(%w[ message tree parents ], params)
+
+        post("/repos/#{user}/#{repo}/git/commits", params)
+      end
+
     end # Commits
   end # GitData
 end # Github

data/lib/github_api/git_data/references.rb

@@ -4,6 +4,110 @@ module Github
   class GitData
     module References
 
+      VALID_REF_PARAM_NAMES = %w[ ref sha force ].freeze
+
+      VALID_REF_PARAM_VALUES = {
+        'ref' => %r{^refs\/\w+\/\w+(\/\w+)*} # test fully qualified reference
+      }
+
+      # Get a reference
+      #
+      # The ref in the URL must be formatted as <tt>heads/branch</tt>,
+      # not just branch. For example, the call to get the data for a
+      # branch named <tt>sc/featureA</tt> would be formatted as
+      # <tt>heads/sc/featureA</tt>
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.reference 'user-name', 'repo-name', 'reference'
+      #
+      def reference(user_name, repo_name, ref, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of ref
+        _normalize_params_keys(params)
+
+        get("/repos/#{user}/#{repo}/git/refs/#{ref}", params)
+      end
+
+      # Get all references
+      #
+      # This will return an array of all the references on the system,
+      # including things like notes and stashes if they exist on the server.
+      # Anything in the namespace, not just <tt>heads</tt> and <tt>tags</tt>,
+      # though that would be the most common.
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.references 'user-name', 'repo-name'
+      #
+      #  @github.git_data.references 'user-name', 'repo-name', 'tags'
+      #
+      def references(user_name, repo_name, ref=nil, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _normalize_params_keys(params)
+
+        response = if ref
+          get("/repos/#{user}/#{repo}/git/refs/#{ref}")
+        else
+          get("/repos/#{user}/#{repo}/git/refs")
+        end
+        return response unless block_given?
+        response.each { |el| yield el }
+      end
+
+      # Create a reference
+      #
+      # = Inputs
+      # * <tt>:ref</tt> - String of the name of the fully qualified reference (ie: refs/heads/master). If it doesn’t start with ‘refs’ and have at least two slashes, it will be rejected.
+      # * <tt>:sha</tt> - String of the SHA1 value to set this reference to
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.create_reference 'user-name', 'repo-name',
+      #    "ref" => "refs/heads/master",
+      #    "sha" =>  "827efc6d56897b048c772eb4087f854f46256132"
+      #
+      def create_reference(user_name, repo_name, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _normalize_params_keys(params)
+
+        raise ArgumentError, "Required params are: ref, sha" unless _validate_inputs(%w[ ref sha ], params)
+
+        _filter_params_keys(VALID_REF_PARAM_NAMES, params)
+        _validate_params_values(VALID_REF_PARAM_VALUES, params)
+
+        post("/repos/#{user}/#{repo}/git/refs", params)
+      end
+
+      # Update a reference
+      #
+      # = Inputs
+      # * <tt>:sha</tt> - String of the SHA1 value to set this reference to
+      # * <tt>:force</tt> - Boolean indicating whether to force the update or to make sure the update is a fast-forward update. The default is <tt>false</tt>, so leaving this out or setting it to false will make sure you’re not overwriting work.
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.create_reference 'user-name', 'repo-name',
+      #    "sha" =>  "827efc6d56897b048c772eb4087f854f46256132",
+      #    "force" => true
+      #
+      def update_reference(user_name, repo_name, ref, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of ref
+        _normalize_params_keys(params)
+
+        raise ArgumentError, "Required params are: sha" unless _validate_inputs(%w[ sha ], params)
+
+        _filter_params_keys(VALID_REF_PARAM_NAMES, params)
+        _validate_params_values(VALID_REF_PARAM_VALUES, params)
+
+        patch("/repos/#{user}/#{repo}/git/refs/#{ref}", params)
+      end
+
     end # References
   end # GitData
 end # Github

data/lib/github_api/git_data/tags.rb

@@ -2,8 +2,77 @@
 
 module Github
   class GitData
+    # This tags api only deals with tag objects - so only annotated tags, not lightweight tags.
     module Tags
 
+      VALID_TAG_PARAM_NAMES = %w[
+        tag
+        message
+        object
+        type
+        name
+        email
+        date
+      ]
+
+      VALID_TAG_PARAM_VALUES = {
+        'type' => %w[ blob tree commit ]
+      }
+
+      # Get a tag
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.tag 'user-name', 'repo-name', 'sha'
+      #
+      def tag(user_name, repo_name, sha, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of sha
+        _normalize_params_keys(params)
+
+        get("/repos/#{user}/#{repo}/git/tags/#{sha}", params)
+      end
+
+      # Create a tag object
+      # Note that creating a tag object does not create the reference that
+      # makes a tag in Git. If you want to create an annotated tag in Git,
+      # you have to do this call to create the tag object, and then create
+      # the <tt>refs/tags/[tag]</tt> reference. If you want to create a lightweight tag, you simply have to create the reference - this call would be unnecessary.
+      #
+      # = Parameters
+      # * <tt>:tag</tt> - String of the tag
+      # * <tt>:message</tt> - String of the tag message
+      # * <tt>:object</tt> - String of the SHA of the git object this is tagging
+      # * <tt>:type</tt> - String of the type of the object we're tagging. Normally this is a <tt>commit</tt> but it can also be a <tt>tree</tt> or a <tt>blob</tt>
+      # * tagger.name:: String of the name of the author of the tag
+      # * tagger.email:: String of the email of the author of the tag
+      # * tagger.date:: Timestamp of when this object was tagged
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.create_tag 'user-name', 'repo-name',
+      #    "tag" =>  "v0.0.1",
+      #    "message" => "initial version\n",
+      #    "type": "commit",
+      #    "object": "c3d0be41ecbe669545ee3e94d31ed9a4bc91ee3c",
+      #    "tagger" => {
+      #      "name" =>  "Scott Chacon",
+      #      "email" => "schacon@gmail.com",
+      #      "date" => "2011-06-17T14:53:3"
+      #    }
+      #
+      def create_tag(user_name, repo_name, 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(VALID_TAG_PARAM_NAMES, params)
+        _validate_params_values(VALID_TAG_PARAM_VALUES, params)
+
+        post("/repos/#{user}/#{repo}/git/tags", params)
+      end
+
     end # Tags
   end # GitData
 end # Github

data/lib/github_api/git_data/trees.rb

@@ -4,6 +4,86 @@ module Github
   class GitData
     module Trees
 
+      VALID_TREE_PARAM_NAMES = %w[
+        base_tree
+        tree
+        path
+        mode
+        type
+        sha
+        content
+      ].freeze
+
+      VALID_TREE_PARAM_VALUES = {
+        'mode' => %w[ 100644 100755 040000 160000 120000 ],
+        'type' => %w[ blob tree commit ]
+      }
+
+      # Get a tree
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.tree 'user-name', 'repo-name', 'sha'
+      #  @github.git_data.tree 'user-name', 'repo-name', 'sha' do |file|
+      #    file.path
+      #  end
+      #
+      def tree(user_name, repo_name, sha, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of sha
+        _normalize_params_keys(params)
+
+        response = if params['recursive']
+          params['recursive'] = 1
+          get("/repos/#{user}/#{repo}/git/trees/#{sha}", params)
+        else
+          get("/repos/#{user}/#{repo}/git/trees/#{sha.to_s}", params)
+        end
+        return response unless block_given?
+        response.tree.each { |el| yield el }
+      end
+
+      # Create a tree
+      #
+      # The tree creation API will take nested entries as well.
+      # If both a tree and a nested path modifying that tree are specified,
+      # it will overwrite the contents of that tree with the new path contents
+      # and write a new tree out.
+      #
+      # = Parameters
+      # * <tt>:base_tree</tt> - optional string of the SHA1 of the tree you want to update with new data
+      # * <tt>:tree</tt> - array of hash objects(of <tt>:path</tt>, <tt>:mode</tt>, <tt>:type</tt> and <tt>sha</tt>)
+      # * tree.path:: String of the file referenced in the tree
+      # * tree.mode:: String of the file mode - one of <tt>100644</tt> for file(blob), <tt>100755</tt> for executable (blob), <tt>040000</tt> for subdirectory (tree), <tt>160000</tt> for submodule (commit) or <tt>120000</tt> for a blob that specifies the path of a symlink
+      # * tree.type:: String of <tt>blob</tt>, <tt>tree</tt>, <tt>commit</tt>
+      # * tree.sha:: String of SHA1 checksum ID of the object in the tree
+      # * tree.content:: String of content you want this file to have - GitHub will write this blob out and use the SHA for this entry. Use either this or <tt>tree.sha</tt>
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.git_data.create_tree 'user-name', 'repo-name',
+      #    "tree" => [
+      #      {
+      #        "path" => "file.rb",
+      #        "mode" => "100644",
+      #        "type" => "blob",
+      #        "sha" => "44b4fc6d56897b048c772eb4087f854f46256132"
+      #      },
+      #      ...
+      #    ]
+      #
+      def create_tree(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(VALID_TREE_PARAM_NAMES, params['tree'])
+        _validate_params_values(VALID_TREE_PARAM_VALUES, params['tree'])
+
+        post("/repos/#{user}/#{repo}/git/trees", params)
+      end
+
     end # Trees
   end # GitData
 end # Github

data/lib/github_api/issues/comments.rb

@@ -15,6 +15,7 @@ module Github
       def issue_comments(user_name, repo_name, issue_id, params={})
         _update_user_repo_params(user_name, repo_name)
         _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of issue_id
         _normalize_params_keys(params)
 
         get("/repos/#{user}/#{repo}/issues/#{issue_id}/comments", params)

data/lib/github_api/orgs/members.rb

@@ -5,6 +5,7 @@ module Github
     module Members
 
       # List members
+      #
       # List all users who are members of an organization. A member is a user 
       # that belongs to at least 1 team in the organization. 
       # If the authenticated user is also a member of this organization then 

data/lib/github_api/repos/keys.rb

@@ -3,48 +3,99 @@
 module Github
   class Repos
     module Keys
-      
-      # List keys
+
+      VALID_KEY_PARAM_NAMES = %w[ title key ].freeze
+
+      # List deploy keys
       #
-      # GET /repos/:user/:repo/keys
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.keys 'user-name', 'repo-name'
+      #  @github.repos.keys 'user-name', 'repo-name' { |key| ... }
       #
-      def keys(user, repo)
-        get("/repos/#{user}/#{repo}/keys")
+      def keys(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)
+
+        response = get("/repos/#{user}/#{repo}/keys")
+        return response unless block_given?
+        response.each { |el| yield el }
       end
 
       # Get a key
       #
-      # GET /repos/:user/:repo/keys/:id
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.get_key 'user-name', 'repo-name', 'key-id'
       #
-      def get_key(user, repo, key_id)
+      def get_key(user_name, repo_name, key_id, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of key_id
+        _normalize_params_keys(params)
+
         get("/repos/#{user}/#{repo}/keys/#{key_id}")
       end
 
       # Create a key
       #
-      # POST /repos/:user/:repo/keys
-      def create_key(user, repo, params={})
+      # = Inputs
+      # * <tt>:title</tt> - Required string.
+      # * <tt>:key</tt> - Required string.
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.create_key 'user-name', 'repo-name',
+      #    "title" => "octocat@octomac",
+      #    "key" =>  "ssh-rsa AAA..."
+      #
+      def create_key(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[ title key ], params)
+        _filter_params_keys(VALID_KEY_PARAM_NAMES, params)
+
+        raise ArgumentError, "Required params are: #{VALID_KEY_PARAM_NAMES.join(', ')}" unless _validate_inputs(VALID_KEY_PARAM_NAMES, params)
 
         post("/repos/#{user}/#{repo}/keys", params)
       end
 
-      # Edit key
+      # Edit a key
+      #
+      # = Inputs
+      # * <tt>:title</tt> - Required string.
+      # * <tt>:key</tt> - Required string.
       #
-      # PATCH /repos/:user/:repo/keys/:id
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.create_key 'user-name', 'repo-name',
+      #    "title" => "octocat@octomac",
+      #    "key" =>  "ssh-rsa AAA..."
       #
-      def edit_key(user, repo, key_id)
+      def edit_key(user_name, repo_name, key_id, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of key_id
+
         _normalize_params_keys(params)
-        _filter_params_keys(%w[ title key ], params)
+        _filter_params_keys(VALID_KEY_PARAM_NAMES, params)
 
         patch("/repos/#{user}/#{repo}/keys/#{key_id}")
       end
-      
+
       # Delete key
       #
-      # DELETE /repos/:user/:repo/keys/:id
-      def delete_key(user, repo, key_id)
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.delete_key 'user-name', 'repo-name', 'key-id'
+      #
+      def delete_key(user_name, repo_name, key_id, params={})
+        _update_user_repo_params(user_name, repo_name)
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _validate_presence_of key_id
+        _normalize_params_keys(params)
+
         delete("/repos/#{user}/#{repo}/keys/#{key_id}")
       end