[maven-release-plugin] prepare release github-api-1.54

Add support for adding deploykeys to repo

.gitignore

@@ -1,4 +1,5 @@
 target
+.idea/
 *.iml
 *.ipr
 *.iws

LICENSE.txt

@@ -0,0 +1,22 @@
+ Copyright (c) 2011- Kohsuke Kawaguchi and other contributors
+
+ 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.

README

@@ -1,3 +1,3 @@
 Java API for GitHub
 
-See http://kohsuke.org/github-api/ for more details
+See http://github-api.kohsuke.org/ for more details

pom.xml

@@ -3,11 +3,11 @@
   <parent>
     <groupId>org.kohsuke</groupId>
     <artifactId>pom</artifactId>
-    <version>1</version>
+    <version>8</version>
   </parent>
 
   <artifactId>github-api</artifactId>
-  <version>1.16</version>
+  <version>1.54</version>
   <name>GitHub API for Java</name>
   <url>http://github-api.kohsuke.org/</url>
   <description>GitHub API for Java</description>
@@ -16,6 +16,7 @@
     <connection>scm:git:git@github.com/kohsuke/${project.artifactId}.git</connection>
     <developerConnection>scm:git:ssh://git@github.com/kohsuke/${project.artifactId}.git</developerConnection>
     <url>http://${project.artifactId}.kohsuke.org/</url>
+    <tag>HEAD</tag>
   </scm>
 
   <distributionManagement>
@@ -25,12 +26,16 @@
     </site>
   </distributionManagement>
 
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
   <build>
     <plugins>
       <plugin>
         <groupId>com.infradna.tool</groupId>
         <artifactId>bridge-method-injector</artifactId>
-        <version>1.2</version>
+        <version>1.12</version>
         <executions>
           <execution>
             <goals>
@@ -44,27 +49,25 @@
 
   <dependencies>
     <dependency>
-      <groupId>org.jvnet.hudson</groupId>
-      <artifactId>htmlunit</artifactId>
-      <version>2.6-hudson-2</version>
-      <exclusions>
-        <exclusion>
-                <!--  hides JDK DOM classes in Eclipse -->
-                <groupId>xml-apis</groupId>
-                <artifactId>xml-apis</artifactId>
-        </exclusion>
-      </exclusions>
+      <groupId>commons-lang</groupId>
+      <artifactId>commons-lang</artifactId>
+      <version>2.6</version>
+    </dependency>
+    <dependency>
+      <groupId>commons-codec</groupId>
+      <artifactId>commons-codec</artifactId>
+      <version>1.7</version>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>3.8.1</version>
+      <version>4.11</version>
       <scope>test</scope>
     </dependency>
     <dependency>
-      <groupId>org.codehaus.jackson</groupId>
-      <artifactId>jackson-mapper-asl</artifactId>
-      <version>1.5.0</version>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.2.3</version>
     </dependency>
     <dependency>
       <groupId>commons-io</groupId>
@@ -74,10 +77,45 @@
     <dependency>
       <groupId>com.infradna.tool</groupId>
       <artifactId>bridge-method-annotation</artifactId>
-      <version>1.4</version>
+      <version>1.12</version>
+    </dependency>
+    <dependency>
+      <groupId>org.kohsuke.stapler</groupId>
+      <artifactId>stapler-jetty</artifactId>
+      <version>1.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.eclipse.jgit</groupId>
+      <artifactId>org.eclipse.jgit</artifactId>
+      <version>3.1.0.201310021548-r</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.squareup.okhttp</groupId>
+      <artifactId>okhttp</artifactId>
+      <version>1.5.3</version>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>org.kohsuke</groupId>
+      <artifactId>wordnet-random-name</artifactId>
+      <version>1.2</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
+  <repositories>
+    <repository>
+      <id>repo.jenkins-ci.org</id>
+      <url>http://repo.jenkins-ci.org/public/</url>
+    </repository>
+  </repositories>
+  <pluginRepositories>
+    <pluginRepository>
+      <id>repo.jenkins-ci.org</id>
+      <url>http://repo.jenkins-ci.org/public/</url>
+    </pluginRepository>
+  </pluginRepositories>
 
   <reporting>
     <plugins>
@@ -87,4 +125,12 @@
       </plugin>
     </plugins>
   </reporting>
+
+  <licenses>
+    <license>
+      <name>The MIT license</name>
+      <url>http://www.opensource.org/licenses/mit-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
 </project>

src/main/java/org/kohsuke/github/ApiVersion.java

@@ -1,17 +0,0 @@
-package org.kohsuke.github;
-
-/**
- * Different API versions.
- *
- * @author Kohsuke Kawaguchi
- */
-enum ApiVersion {
-    V2("https://github.com/api/v2/json"),
-    V3("https://api.github.com");
-
-    final String url;
-
-    ApiVersion(String url) {
-        this.url = url;
-    }
-}

src/main/java/org/kohsuke/github/GHAsset.java

@@ -0,0 +1,108 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * Asset in a release.
+ *
+ * @see GHRelease#getAssets()
+ */
+public class GHAsset {
+    GitHub root;
+    GHRepository owner;
+    private String url;
+    private String id;
+    private String name;
+    private String label;
+    private String state;
+    private String content_type;
+    private long size;
+    private long download_count;
+    private Date created_at;
+    private Date updated_at;
+
+    public String getContentType() {
+        return content_type;
+    }
+
+    public void setContentType(String contentType) throws IOException {
+        edit("content_type", contentType);
+        this.content_type = contentType;
+    }
+
+    public Date getCreatedAt() {
+        return created_at;
+    }
+
+    public long getDownloadCount() {
+        return download_count;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) throws IOException {
+        edit("label", label);
+        this.label = label;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public GHRepository getOwner() {
+        return owner;
+    }
+
+    public GitHub getRoot() {
+        return root;
+    }
+
+    public long getSize() {
+        return size;
+    }
+
+    public String getState() {
+        return state;
+    }
+
+    public Date getUpdatedAt() {
+        return updated_at;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    private void edit(String key, Object value) throws IOException {
+        new Requester(root)._with(key, value).method("PATCH").to(getApiRoute());
+    }
+
+    public void delete() throws IOException {
+        new Requester(root).method("DELETE").to(getApiRoute());
+    }
+
+
+    private String getApiRoute() {
+        return "/repos/" + owner.getOwnerName() + "/" + owner.getName() + "/releases/assets/" + id;
+    }
+
+    GHAsset wrap(GHRelease release) {
+        this.owner = release.getOwner();
+        this.root = owner.root;
+        return this;
+    }
+
+    public static GHAsset[] wrap(GHAsset[] assets, GHRelease release) {
+        for (GHAsset aTo : assets) {
+            aTo.wrap(release);
+        }
+        return assets;
+    }
+}

src/main/java/org/kohsuke/github/GHAuthorization.java

@@ -0,0 +1,94 @@
+package org.kohsuke.github;
+
+import java.net.URL;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Generated OAuth token
+ *
+ * @author janinko
+ * @see GitHub#createToken(Collection, String, String)
+ * @see http://developer.github.com/v3/oauth/#create-a-new-authorization
+ */
+public class GHAuthorization {
+	public static final String USER = "user";
+	public static final String USER_EMAIL = "user:email";
+	public static final String USER_FOLLOW = "user:follow";
+	public static final String PUBLIC_REPO = "public_repo";
+	public static final String REPO = "repo";
+	public static final String REPO_STATUS = "repo:status";
+	public static final String DELETE_REPO = "delete_repo";
+	public static final String NOTIFICATIONS = "notifications";
+	public static final String GIST = "gist";
+
+	private GitHub root;
+	private int id;
+	private String url;
+	private List<String> scopes;
+	private String token;
+	private App app;
+	private String note;
+	private String note_url;
+	private String updated_at;
+	private String created_at;
+
+    public GitHub getRoot() {
+        return root;
+    }
+
+	public int getId() {
+		return id;
+	}
+
+	public List<String> getScopes() {
+		return scopes;
+	}
+
+	public String getToken(){
+		return token;
+	}
+
+	public URL getAppUrl(){
+        return GitHub.parseURL(app.url);
+	}
+
+	public String getAppName() {
+		return app.name;
+	}
+   
+	public URL getApiURL(){
+        return GitHub.parseURL(url);
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public URL getNoteUrl(){
+        return GitHub.parseURL(note_url);
+	}
+	
+	public Date getCreatedAt() {
+        return GitHub.parseDate(created_at);
+    }
+
+    public Date getUpdatedAt() {
+        return GitHub.parseDate(updated_at);
+    }
+
+	/*package*/ GHAuthorization wrap(GitHub root) {
+		this.root = root;
+		return this;
+	}
+
+
+
+
+
+	private static class App{
+		private String url;
+		private String name;
+	}
+}

src/main/java/org/kohsuke/github/GHBranch.java

@@ -0,0 +1,51 @@
+package org.kohsuke.github;
+
+/**
+ * A branch in a repository.
+ * 
+ * @author Yusuke Kokubo
+ */
+public class GHBranch {
+    private GitHub root;
+    private GHRepository owner;
+
+    private String name;
+    private Commit commit;
+
+    public static class Commit {
+        String sha,url;
+    }
+
+    public GitHub getRoot() {
+        return root;
+    }
+
+    /**
+     * Repository that this branch is in.
+     */
+    public GHRepository getOwner() {
+        return owner;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * The commit that this branch currently points to.
+     */
+    public String getSHA1() {
+        return commit.sha;
+    }
+
+    @Override
+    public String toString() {
+        return "Branch:" + name + " in " + owner.getUrl();
+    }
+
+    /*package*/ GHBranch wrap(GHRepository repo) {
+        this.owner = repo;
+        this.root = repo.root;
+        return this;
+    }
+}

src/main/java/org/kohsuke/github/GHCommit.java

@@ -0,0 +1,303 @@
+package org.kohsuke.github;
+
+import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A commit in a repository.
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GHRepository#getCommit(String)
+ * @see GHCommitComment#getCommit()
+ */
+public class GHCommit {
+    private GHRepository owner;
+    
+    private ShortInfo commit;
+
+    /**
+     * Short summary of this commit.
+     */
+    public static class ShortInfo {
+        private GHAuthor author;
+        private GHAuthor committer;
+        
+        private String message;
+        
+        private int comment_count;
+
+        @WithBridgeMethods(value=GHAuthor.class,castRequired=true)
+    	public GitUser getAuthor() {
+    		return author;
+    	}
+
+        @WithBridgeMethods(value=GHAuthor.class,castRequired=true)
+		public GitUser getCommitter() {
+			return committer;
+		}
+
+        /**
+         * Commit message.
+         */
+		public String getMessage() {
+			return message;
+		}
+
+		public int getCommentCount() {
+			return comment_count;
+		}
+    }
+
+    /**
+     * @deprecated Use {@link GitUser} instead.
+     */
+    public static class GHAuthor extends GitUser {
+    }
+
+    public static class Stats {
+        int total,additions,deletions;
+    }
+
+    /**
+     * A file that was modified.
+     */
+    public static class File {
+        String status;
+        int changes,additions,deletions;
+        String raw_url, blob_url, filename, sha, patch;
+
+        /**
+         * Number of lines added + removed.
+         */
+        public int getLinesChanged() {
+            return changes;
+        }
+
+        /**
+         * Number of lines added.
+         */
+        public int getLinesAdded() {
+            return additions;
+        }
+
+        /**
+         * Number of lines removed.
+         */
+        public int getLinesDeleted() {
+            return deletions;
+        }
+
+        /**
+         * "modified", "added", or "deleted"
+         */
+        public String getStatus() {
+            return status;
+        }
+
+        /**
+         * Just the base name and the extension without any directory name.
+         */
+        public String getFileName() {
+            return filename;
+        }
+
+        /**
+         * The actual change.
+         */
+        public String getPatch() {
+            return patch;
+        }
+
+        /**
+         * URL like 'https://raw.github.com/jenkinsci/jenkins/4eb17c197dfdcf8ef7ff87eb160f24f6a20b7f0e/core/pom.xml'
+         * that resolves to the actual content of the file.
+         */
+        public URL getRawUrl() {
+            return GitHub.parseURL(raw_url);
+        }
+
+        /**
+         * URL like 'https://github.com/jenkinsci/jenkins/blob/1182e2ebb1734d0653142bd422ad33c21437f7cf/core/pom.xml'
+         * that resolves to the HTML page that describes this file.
+         */
+        public URL getBlobUrl() {
+            return GitHub.parseURL(blob_url);
+        }
+
+        /**
+         * [0-9a-f]{40} SHA1 checksum.
+         */
+        public String getSha() {
+            return sha;
+        }
+    }
+
+    public static class Parent {
+        String url,sha;
+    }
+
+    static class User {
+        // TODO: what if someone who doesn't have an account on GitHub makes a commit?
+        String url,avatar_url,login,gravatar_id;
+        int id;
+    }
+
+    String url,sha;
+    List<File> files;
+    Stats stats;
+    List<Parent> parents;
+    User author,committer;
+    
+    
+
+    public ShortInfo getCommitShortInfo() {
+		return commit;
+	}
+
+	/**
+     * The repository that contains the commit.
+     */
+    public GHRepository getOwner() {
+        return owner;
+    }
+
+    /**
+     * Number of lines added + removed.
+     */
+    public int getLinesChanged() {
+        return stats.total;
+    }
+
+    /**
+     * Number of lines added.
+     */
+    public int getLinesAdded() {
+        return stats.additions;
+    }
+
+    /**
+     * Number of lines removed.
+     */
+    public int getLinesDeleted() {
+        return stats.deletions;
+    }
+
+    /**
+     * [0-9a-f]{40} SHA1 checksum.
+     */
+    public String getSHA1() {
+        return sha;
+    }
+
+    /**
+     * List of files changed/added/removed in this commit.
+     *
+     * @return
+     *      Can be empty but never null.
+     */
+    public List<File> getFiles() {
+        return files!=null ? Collections.unmodifiableList(files) : Collections.<File>emptyList();
+    }
+
+    /**
+     * Returns the SHA1 of parent commit objects.
+     */
+    public List<String> getParentSHA1s() {
+        if (parents==null)  return Collections.emptyList();
+        return new AbstractList<String>() {
+            @Override
+            public String get(int index) {
+                return parents.get(index).sha;
+            }
+
+            @Override
+            public int size() {
+                return parents.size();
+            }
+        };
+    }
+
+    /**
+     * Resolves the parent commit objects and return them.
+     */
+    public List<GHCommit> getParents() throws IOException {
+        List<GHCommit> r = new ArrayList<GHCommit>();
+        for (String sha1 : getParentSHA1s())
+            r.add(owner.getCommit(sha1));
+        return r;
+    }
+
+    public GHUser getAuthor() throws IOException {
+        return resolveUser(author);
+    }
+
+    public GHUser getCommitter() throws IOException {
+        return resolveUser(committer);
+    }
+
+    private GHUser resolveUser(User author) throws IOException {
+        if (author==null || author.login==null) return null;
+        return owner.root.getUser(author.login);
+    }
+
+    /**
+     * Lists up all the commit comments in this repository.
+     */
+    public PagedIterable<GHCommitComment> listComments() {
+        return new PagedIterable<GHCommitComment>() {
+            public PagedIterator<GHCommitComment> iterator() {
+                return new PagedIterator<GHCommitComment>(owner.root.retrieve().asIterator(String.format("/repos/%s/%s/commits/%s/comments", owner.getOwnerName(), owner.getName(), sha), GHCommitComment[].class)) {
+                    @Override
+                    protected void wrapUp(GHCommitComment[] page) {
+                        for (GHCommitComment c : page)
+                            c.wrap(owner);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Creates a commit comment.
+     *
+     * I'm not sure how path/line/position parameters interact with each other.
+     */
+    public GHCommitComment createComment(String body, String path, Integer line, Integer position) throws IOException {
+        GHCommitComment r = new Requester(owner.root)
+                .with("body",body)
+                .with("path",path)
+                .with("line",line)
+                .with("position",position)
+                .to(String.format("/repos/%s/%s/commits/%s/comments",owner.getOwnerName(),owner.getName(),sha),GHCommitComment.class);
+        return r.wrap(owner);
+    }
+
+    public GHCommitComment createComment(String body) throws IOException {
+        return createComment(body,null,null,null);
+    }
+
+    /**
+     * Gets the status of this commit, newer ones first.
+     */
+    public PagedIterable<GHCommitStatus> listStatuses() throws IOException {
+        return owner.listCommitStatuses(sha);
+    }
+
+    /**
+     * Gets the last status of this commit, which is what gets shown in the UI.
+     */
+    public GHCommitStatus getLastStatus() throws IOException {
+        return owner.getLastCommitStatus(sha);
+    }
+
+    GHCommit wrapUp(GHRepository owner) {
+        this.owner = owner;
+        return this;
+    }
+}

src/main/java/org/kohsuke/github/GHCommitComment.java

@@ -0,0 +1,122 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.Date;
+
+/**
+ * A comment attached to a commit (or a specific line in a specific file of a commit.)
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GHRepository#listCommitComments()
+ * @see GHCommit#listComments()
+ * @see GHCommit#createComment(String, String, Integer, Integer)
+ */
+public class GHCommitComment {
+    private GHRepository owner;
+
+    String updated_at, created_at;
+    String body, url, html_url, commit_id;
+    Integer line;
+    int id;
+    String path;
+    User user;
+
+    static class User {
+        // TODO: what if someone who doesn't have an account on GitHub makes a commit?
+        String url,avatar_url,login,gravatar_id;
+        int id;
+    }
+
+    public GHRepository getOwner() {
+        return owner;
+    }
+
+    public Date getCreatedAt() {
+        return GitHub.parseDate(created_at);
+    }
+
+    public Date getUpdatedAt() {
+        return GitHub.parseDate(updated_at);
+    }
+
+    /**
+     * URL like 'https://github.com/kohsuke/sandbox-ant/commit/8ae38db0ea5837313ab5f39d43a6f73de3bd9000#commitcomment-1252827' to
+     * show this commit comment in a browser.
+     */
+    public URL getHtmlUrl() {
+        return GitHub.parseURL(html_url);
+    }
+
+    public String getSHA1() {
+        return commit_id;
+    }
+
+    /**
+     * Commit comment in the GitHub flavored markdown format.
+     */
+    public String getBody() {
+        return body;
+    }
+
+    /**
+     * A commit comment can be on a specific line of a specific file, if so, this field points to a file.
+     * Otherwise null.
+     */
+    public String getPath() {
+        return path;
+    }
+
+    /**
+     * A commit comment can be on a specific line of a specific file, if so, this field points to the line number in the file.
+     * Otherwise -1.
+     */
+    public int getLine() {
+        return line!=null ? line : -1;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    /**
+     * Gets the user who put this comment.
+     */
+    public GHUser getUser() throws IOException {
+        return owner.root.getUser(user.login);
+    }
+
+    /**
+     * Gets the commit to which this comment is associated with.
+     */
+    public GHCommit getCommit() throws IOException {
+        return getOwner().getCommit(getSHA1());
+    }
+
+    /**
+     * Updates the body of the commit message.
+     */
+    public void update(String body) throws IOException {
+        GHCommitComment r = new Requester(owner.root)
+                .with("body", body)
+                .method("PATCH").to(getApiTail(), GHCommitComment.class);
+        this.body = body;
+    }
+
+    /**
+     * Deletes this comment.
+     */
+    public void delete() throws IOException {
+        new Requester(owner.root).method("DELETE").to(getApiTail());
+    }
+
+    private String getApiTail() {
+        return String.format("/repos/%s/%s/comments/%s",owner.getOwnerName(),owner.getName(),id);
+    }
+
+
+    GHCommitComment wrap(GHRepository owner) {
+        this.owner = owner;
+        return this;
+    }
+}

src/main/java/org/kohsuke/github/GHCommitPointer.java

@@ -31,11 +31,11 @@ package org.kohsuke.github;
 public class GHCommitPointer {
     private String ref, sha, label;
     private GHUser user;
-    private GHRepository repository;
+    private GHRepository repo;
 
     /**
      * This points to the user who owns
-     * the {@link #repository}.
+     * the {@link #getRepository()}.
      */
     public GHUser getUser() {
         return user;
@@ -45,11 +45,11 @@ public class GHCommitPointer {
      * The repository that contains the commit.
      */
     public GHRepository getRepository() {
-        return repository;
+        return repo;
     }
 
     /**
-     * Named ref to the commit.
+     * Named ref to the commit. This appears to be a "short ref" that doesn't include "refs/heads/" portion.
      */
     public String getRef() {
         return ref;
@@ -68,4 +68,9 @@ public class GHCommitPointer {
     public String getLabel() {
         return label;
     }
+
+    void wrapUp(GitHub root) {
+        if (user!=null) user.root = root;
+        if (repo!=null) repo.wrap(root);
+    }
 }

src/main/java/org/kohsuke/github/GHCommitQueryBuilder.java

@@ -0,0 +1,105 @@
+package org.kohsuke.github;
+
+import java.util.Date;
+
+/**
+ * Builds up query for listing commits.
+ *
+ * <p>
+ * Call various methods that set the filter criteria, then {@link #list()} method to actually list up the commit.
+ *
+ * <pre>
+ * GHRepository r = ...;
+ * for (GHCommit c : r.queryCommits().since(x).until(y).author("kohsuke")) {
+ *     ...
+ * }
+ * </pre>
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GHRepository#queryCommits()
+*/
+public class GHCommitQueryBuilder {
+    private final Requester req;
+    private final GHRepository repo;
+
+    /*package*/ GHCommitQueryBuilder(GHRepository repo) {
+        this.repo = repo;
+        this.req = repo.root.retrieve();    // requester to build up
+    }
+
+    /**
+     * GItHub login or email address by which to filter by commit author.
+     */
+    public GHCommitQueryBuilder author(String author) {
+        req.with("author",author);
+        return this;
+    }
+
+    /**
+     * Only commits containing this file path will be returned.
+     */
+    public GHCommitQueryBuilder path(String path) {
+        req.with("path",path);
+        return this;
+    }
+
+    /**
+     * Specifies the SHA1 commit / tag / branch / etc to start listing commits from.
+     *
+     */
+    public GHCommitQueryBuilder from(String ref) {
+        req.with("sha",ref);
+        return this;
+    }
+
+    public GHCommitQueryBuilder pageSize(int pageSize) {
+        req.with("per_page",pageSize);
+        return this;
+    }
+
+    /**
+     * Only commits after this date will be returned
+     */
+    public GHCommitQueryBuilder since(Date dt) {
+        req.with("since",GitHub.printDate(dt));
+        return this;
+    }
+
+    /**
+     * Only commits after this date will be returned
+     */
+    public GHCommitQueryBuilder since(long timestamp) {
+        return since(new Date(timestamp));
+    }
+
+    /**
+     * Only commits before this date will be returned
+     */
+    public GHCommitQueryBuilder until(Date dt) {
+        req.with("until",GitHub.printDate(dt));
+        return this;
+    }
+
+    /**
+     * Only commits before this date will be returned
+     */
+    public GHCommitQueryBuilder until(long timestamp) {
+        return until(new Date(timestamp));
+    }
+
+    /**
+     * Lists up the commits with the criteria built so far.
+     */
+    public PagedIterable<GHCommit> list() {
+        return new PagedIterable<GHCommit>() {
+            public PagedIterator<GHCommit> iterator() {
+                return new PagedIterator<GHCommit>(req.asIterator(repo.getApiTailUrl("commits"), GHCommit[].class)) {
+                    protected void wrapUp(GHCommit[] page) {
+                        for (GHCommit c : page)
+                            c.wrapUp(repo);
+                    }
+                };
+            }
+        };
+    }
+}

src/main/java/org/kohsuke/github/GHCommitState.java

@@ -0,0 +1,11 @@
+package org.kohsuke.github;
+
+/**
+ * Represents the state of commit
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GHCommitStatus
+ */
+public enum GHCommitState {
+    PENDING, SUCCESS, ERROR, FAILURE
+}

src/main/java/org/kohsuke/github/GHCommitStatus.java

@@ -0,0 +1,72 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * Represents a status of a commit.
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GHRepository#getCommitStatus(String)
+ * @see GHCommit#getStatus()
+ */
+public class GHCommitStatus {
+    String created_at, updated_at;
+    String state;
+    String target_url,description;
+    int id;
+    String url;
+    GHUser creator;
+
+    private GitHub root;
+
+    /*package*/ GHCommitStatus wrapUp(GitHub root) {
+        if (creator!=null)  creator.wrapUp(root);
+        this.root = root;
+        return this;
+    }
+
+    public Date getCreatedAt() {
+        return GitHub.parseDate(created_at);
+    }
+
+    public Date getUpdatedAt() {
+        return GitHub.parseDate(updated_at);
+    }
+
+    public GHCommitState getState() {
+        for (GHCommitState s : GHCommitState.values()) {
+            if (s.name().equalsIgnoreCase(state))
+                return s;
+        }
+        throw new IllegalStateException("Unexpected state: "+state);
+    }
+
+    /**
+     * The URL that this status is linked to.
+     *
+     * This is the URL specified when creating a commit status.
+     */
+    public String getTargetUrl() {
+        return target_url;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    /**
+     * API URL of this commit status.
+     */
+    public String getUrl() {
+        return url;
+    }
+
+    public GHUser getCreator() {
+        return creator;
+    }
+}

src/main/java/org/kohsuke/github/GHCompare.java

@@ -0,0 +1,150 @@
+package org.kohsuke.github;
+
+import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
+
+import java.net.URL;
+import java.util.Date;
+
+/**
+ * The model user for comparing 2 commits in the GitHub API.
+ *
+ * @author Michael Clarke
+ */
+public class GHCompare {
+
+    private String url, html_url, permalink_url, diff_url, patch_url;
+    public Status status;
+    private int ahead_by, behind_by, total_commits;
+    private Commit base_commit, merge_base_commit;
+    private Commit[] commits;
+    private GHCommit.File[] files;
+
+    private GHRepository owner;
+
+    public URL getUrl() {
+        return GitHub.parseURL(url);
+    }
+
+    public URL getHtmlUrl() {
+        return GitHub.parseURL(html_url);
+    }
+
+    public URL getPermalinkUrl() {
+        return GitHub.parseURL(permalink_url);
+    }
+
+    public URL getDiffUrl() {
+        return GitHub.parseURL(diff_url);
+    }
+
+    public URL getPatchUrl() {
+        return GitHub.parseURL(patch_url);
+    }
+
+    public Status getStatus() {
+        return status;
+    }
+
+    public int getAheadBy() {
+        return ahead_by;
+    }
+
+    public int getBehindBy() {
+        return behind_by;
+    }
+
+    public int getTotalCommits() {
+        return total_commits;
+    }
+
+    public Commit getBaseCommit() {
+        return base_commit;
+    }
+
+    public Commit getMergeBaseCommit() {
+        return merge_base_commit;
+    }
+
+    public Commit[] getCommits() {
+        return commits;
+    }
+
+
+    public GHCompare wrap(GHRepository owner) {
+        this.owner = owner;
+        for (Commit commit : commits) {
+            commit.wrapUp(owner);
+        }
+        merge_base_commit.wrapUp(owner);
+        base_commit.wrapUp(owner);
+        return this;
+    }
+
+    /**
+     * Compare commits had a child commit element with additional details we want to capture.
+     * This extenstion of GHCommit provides that.
+     */
+    public static class Commit extends GHCommit {
+
+        private InnerCommit commit;
+
+        public InnerCommit getCommit() {
+            return commit;
+        }
+    }
+
+
+    public static class InnerCommit {
+        private String url, sha, message;
+        private User author, committer;
+        private Tree tree;
+
+        public String getUrl() {
+            return url;
+        }
+
+        public String getSha() {
+            return sha;
+        }
+
+        public String getMessage() {
+            return message;
+        }
+
+        @WithBridgeMethods(value=User.class,castRequired=true)
+        public GitUser getAuthor() {
+            return author;
+        }
+
+        @WithBridgeMethods(value=User.class,castRequired=true)
+        public GitUser getCommitter() {
+            return committer;
+        }
+
+        public Tree getTree() {
+            return tree;
+        }
+    }
+
+    public static class Tree {
+        private String url, sha;
+
+        public String getUrl() {
+            return url;
+        }
+
+        public String getSha() {
+            return sha;
+        }
+    }
+
+    /**
+     * @deprecated use {@link GitUser} instead.
+     */
+    public static class User extends GitUser {
+    }
+
+    public static enum Status {
+        behind, ahead, identical
+    }
+}

src/main/java/org/kohsuke/github/GHContent.java

@@ -0,0 +1,194 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.xml.bind.DatatypeConverter;
+
+/**
+ * A Content of a repository.
+ *
+ * @author Alexandre COLLIGNON
+ * @see GHRepository#getFileContent(String)
+ */
+@SuppressWarnings({"UnusedDeclaration"})
+public class GHContent {
+    private GHRepository owner;
+
+    private String type;
+    private String encoding;
+    private long size;
+    private String sha;
+    private String name;
+    private String path;
+    private String content;
+    private String url; // this is the API url
+    private String git_url;    // this is the Blob url
+    private String html_url;    // this is the UI
+
+    public GHRepository getOwner() {
+        return owner;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public String getEncoding() {
+        return encoding;
+    }
+
+    public long getSize() {
+        return size;
+    }
+
+    public String getSha() {
+        return sha;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    /**
+     * Retrieve the decoded content that is stored at this location.
+     *
+     * Due to the nature of GitHub's API, you're not guaranteed that
+     * the content will already be populated, so this may trigger
+     * network activity, and can throw an IOException.
+    **/
+    public String getContent() throws IOException {
+        return new String(DatatypeConverter.parseBase64Binary(getEncodedContent()));
+    }
+
+    /**
+     * Retrieve the raw content that is stored at this location.
+     *
+     * Due to the nature of GitHub's API, you're not guaranteed that
+     * the content will already be populated, so this may trigger
+     * network activity, and can throw an IOException.
+    **/
+    public String getEncodedContent() throws IOException {
+        if (content != null)
+            return content;
+
+        GHContent retrievedContent = owner.getFileContent(path);
+
+        this.size = retrievedContent.size;
+        this.sha = retrievedContent.sha;
+        this.content = retrievedContent.content;
+        this.url = retrievedContent.url;
+        this.git_url = retrievedContent.git_url;
+        this.html_url = retrievedContent.html_url;
+
+        return content;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public String getGitUrl() {
+        return git_url;
+    }
+
+    public String getHtmlUrl() {
+        return html_url;
+    }
+
+    public boolean isFile() {
+        return "file".equals(type);
+    }
+
+    public boolean isDirectory() {
+        return "dir".equals(type);
+    }
+
+    /**
+     * List immediate children of this directory.
+     */
+    public PagedIterable<GHContent> listDirectoryContent() throws IOException {
+        if (!isDirectory())
+            throw new IllegalStateException(path+" is not a directory");
+
+        return new PagedIterable<GHContent>() {
+            public PagedIterator<GHContent> iterator() {
+                return new PagedIterator<GHContent>(owner.root.retrieve().asIterator(url, GHContent[].class)) {
+                    @Override
+                    protected void wrapUp(GHContent[] page) {
+                        GHContent.wrap(page,owner);
+                    }
+                };
+            }
+        };
+    }
+
+    public GHContentUpdateResponse update(String newContent, String commitMessage) throws IOException {
+        return update(newContent, commitMessage, null);
+    }
+
+    public GHContentUpdateResponse update(String newContent, String commitMessage, String branch) throws IOException {
+        String encodedContent = DatatypeConverter.printBase64Binary(newContent.getBytes());
+
+        Requester requester = new Requester(owner.root)
+            .with("path", path)
+            .with("message", commitMessage)
+            .with("sha", sha)
+            .with("content", encodedContent)
+            .method("PUT");
+
+        if (branch != null) {
+            requester.with("branch", branch);
+        }
+
+        GHContentUpdateResponse response = requester.to(getApiRoute(), GHContentUpdateResponse.class);
+
+        response.getContent().wrap(owner);
+        response.getCommit().wrapUp(owner);
+
+        this.content = encodedContent;
+        return response;
+    }
+
+    public GHContentUpdateResponse delete(String message) throws IOException {
+        return delete(message, null);
+    }
+
+    public GHContentUpdateResponse delete(String commitMessage, String branch) throws IOException {
+        Requester requester = new Requester(owner.root)
+            .with("path", path)
+            .with("message", commitMessage)
+            .with("sha", sha)
+            .method("DELETE");
+
+        if (branch != null) {
+            requester.with("branch", branch);
+        }
+
+        GHContentUpdateResponse response = requester.to(getApiRoute(), GHContentUpdateResponse.class);
+
+        response.getCommit().wrapUp(owner);
+        return response;
+    }
+
+    private String getApiRoute() {
+        return "/repos/" + owner.getOwnerName() + "/" + owner.getName() + "/contents/" + path;
+    }
+
+    GHContent wrap(GHRepository owner) {
+        this.owner = owner;
+        return this;
+    }
+
+    public static GHContent[] wrap(GHContent[] contents, GHRepository repository) {
+        for (GHContent unwrappedContent : contents) {
+            unwrappedContent.wrap(repository);
+        }
+        return contents;
+    }
+}

src/main/java/org/kohsuke/github/GHContentUpdateResponse.java

@@ -0,0 +1,18 @@
+package org.kohsuke.github;
+
+/**
+ * The response that is returned when updating
+ * repository content.
+**/
+public final class GHContentUpdateResponse {
+    private GHContent content;
+    private GHCommit commit;
+
+    public GHContent getContent() {
+        return content;
+    }
+
+    public GHCommit getCommit() {
+        return commit;
+    }
+}

src/main/java/org/kohsuke/github/GHDeployKey.java

@@ -0,0 +1,46 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+
+import org.apache.commons.lang.builder.ToStringBuilder;
+
+public class GHDeployKey {
+
+    protected String url, key, title;
+    protected boolean verified;
+    protected int id;
+	private GHRepository owner;
+
+    public int getId() {
+        return id;
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public boolean isVerified() {
+        return verified;
+    }
+
+	public GHDeployKey wrap(GHRepository repo) {
+		this.owner = repo;
+		return this;
+	}
+
+    public String toString() {
+        return new ToStringBuilder(this).append("title",title).append("id",id).append("key",key).toString();
+    }
+    
+    public void delete() throws IOException {
+        new Requester(owner.root).method("DELETE").to(String.format("/repos/%s/%s/keys/%d", owner.getOwnerName(), owner.getName(), id));
+    }
+}

src/main/java/org/kohsuke/github/GHEmail.java

@@ -23,19 +23,47 @@
  */
 package org.kohsuke.github;
 
-import java.util.List;
 
 /**
- * @author Kohsuke Kawaguchi
+ * Represents an email of GitHub.
+ *
+ * @author Kelly Campbell
  */
-class JsonPullRequests {
-    public List<GHPullRequest> pulls;
+public class GHEmail {
 
-    public List<GHPullRequest> wrap(GHRepository owner) {
-        for (GHPullRequest pull : pulls) {
-            pull.owner = owner;
-            pull.root = owner.root;
+    protected String email;
+    protected boolean primary;
+    protected boolean verified;
+
+    public String getEmail() {
+        return email;
+    }
+
+    public boolean isPrimary() {
+        return primary;
+    }
+
+    public boolean isVerified() {
+        return verified;
+    }
+
+
+    @Override
+    public String toString() {
+        return "Email:"+email;
+    }
+
+    @Override
+    public int hashCode() {
+        return email.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof GHEmail) {
+            GHEmail that = (GHEmail) obj;
+            return this.email.equals(that.email);
         }
-        return pulls;
+        return false;
     }
 }

src/main/java/org/kohsuke/github/GHEvent.java

@@ -6,6 +6,7 @@ package org.kohsuke.github;
  * See http://developer.github.com/v3/events/types/
  *
  * @author Kohsuke Kawaguchi
+ * @see GHEventInfo
  */
 public enum GHEvent {
     COMMIT_COMMENT,
@@ -22,6 +23,7 @@ public enum GHEvent {
     MEMBER,
     PUBLIC,
     PULL_REQUEST,
+    PULL_REQUEST_REVIEW_COMMENT,
     PUSH,
     TEAM_ADD,
     WATCH

src/main/java/org/kohsuke/github/GHEventInfo.java

@@ -0,0 +1,89 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.util.Date;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/**
+ * Represents an event.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public class GHEventInfo {
+    private GitHub root;
+
+    // we don't want to expose Jackson dependency to the user. This needs databinding
+    private ObjectNode payload;
+
+    private String created_at;
+    private String type;
+
+    // these are all shallow objects
+    private GHEventRepository repo;
+    private GHUser actor;
+    private GHOrganization org;
+
+    /**
+     * Inside the event JSON model, GitHub uses a slightly different format.
+     */
+    public static class GHEventRepository {
+        private int id;
+        private String url;     // repository API URL
+        private String name;    // owner/repo
+    }
+
+    public GHEvent getType() {
+        String t = type;
+        if (t.endsWith("Event"))    t=t.substring(0,t.length()-5);
+        for (GHEvent e : GHEvent.values()) {
+            if (e.name().replace("_","").equalsIgnoreCase(t))
+                return e;
+        }
+        return null;    // unknown event type
+    }
+
+    /*package*/ GHEventInfo wrapUp(GitHub root) {
+        this.root = root;
+        return this;
+    }
+
+    public Date getCreatedAt() {
+        return GitHub.parseDate(created_at);
+    }
+
+    /**
+     * Repository where the change was made.
+     */
+    public GHRepository getRepository() throws IOException {
+        return root.getRepository(repo.name);
+    }
+    
+    public GHUser getActor() throws IOException {
+        return root.getUser(actor.getLogin());
+    }
+
+    /**
+     * Quick way to just get the actor of the login.
+     */
+    public String getActorLogin() throws IOException {
+        return actor.getLogin();
+    }
+
+    public GHOrganization getOrganization() throws IOException {
+        return (org==null || org.getLogin()==null) ? null : root.getOrganization(org.getLogin());
+    }
+
+    /**
+     * Retrieves the payload.
+     * 
+     * @param type
+     *      Specify one of the {@link GHEventPayload} subtype that defines a type-safe access to the payload.
+     *      This must match the {@linkplain #getType() event type}.
+     */
+    public <T extends GHEventPayload> T getPayload(Class<T> type) throws IOException {
+        T v = GitHub.MAPPER.readValue(payload.traverse(), type);
+        v.wrapUp(root);
+        return v;
+    }
+}

src/main/java/org/kohsuke/github/GHEventPayload.java

@@ -0,0 +1,196 @@
+package org.kohsuke.github;
+
+import java.io.Reader;
+import java.util.List;
+
+/**
+ * Base type for types used in databinding of the event payload.
+ * 
+ * @see GitHub#parseEventPayload(Reader, Class)
+ * @see GHEventInfo#getPayload(Class)
+ */
+@SuppressWarnings("UnusedDeclaration")
+public abstract class GHEventPayload {
+    protected GitHub root;
+
+    /*package*/ GHEventPayload() {
+    }
+
+    /*package*/ void wrapUp(GitHub root) {
+        this.root = root;
+    }
+
+    /**
+     * A pull request status has changed.
+     *
+     * @see <a href="http://developer.github.com/v3/activity/events/types/#pullrequestevent">authoritative source</a>
+     */
+    public static class PullRequest extends GHEventPayload {
+        private String action;
+        private int number;
+        private GHPullRequest pull_request;
+        private GHRepository repository;
+
+        public String getAction() {
+            return action;
+        }
+
+        public int getNumber() {
+            return number;
+        }
+
+        public GHPullRequest getPullRequest() {
+            pull_request.root = root;
+            return pull_request;
+        }
+
+        public GHRepository getRepository() {
+            return repository;
+        }
+
+        @Override
+        void wrapUp(GitHub root) {
+            super.wrapUp(root);
+            if (pull_request==null)
+                throw new IllegalStateException("Expected pull_request payload, but got something else. Maybe we've got another type of event?");
+            if (repository!=null) {
+                repository.wrap(root);
+                pull_request.wrap(repository);
+            } else {
+                pull_request.wrapUp(root);
+            }
+        }
+    }
+
+    /**
+     * A comment was added to an issue
+     *
+     * @see <a href="http://developer.github.com/v3/activity/events/types/#issuecommentevent">authoritative source</a>
+     */
+    public static class IssueComment extends GHEventPayload {
+        private String action;
+        private GHIssueComment comment;
+        private GHIssue issue;
+        private GHRepository repository;
+
+        public String getAction() {
+            return action;
+        }
+
+        public GHIssueComment getComment() {
+            return comment;
+        }
+
+        public void setComment(GHIssueComment comment) {
+            this.comment = comment;
+        }
+
+        public GHIssue getIssue() {
+            return issue;
+        }
+
+        public void setIssue(GHIssue issue) {
+            this.issue = issue;
+        }
+
+        public GHRepository getRepository() {
+            return repository;
+        }
+
+        public void setRepository(GHRepository repository) {
+            this.repository = repository;
+        }
+
+        @Override
+        void wrapUp(GitHub root) {
+            super.wrapUp(root);
+            repository.wrap(root);
+            issue.wrap(repository);
+            comment.wrapUp(issue);
+        }
+    }
+
+    /**
+     * A commit was pushed.
+     *
+     * @see <a href="http://developer.github.com/v3/activity/events/types/#pushevent">authoritative source</a>
+     */
+    public static class Push extends GHEventPayload {
+        private String head, before;
+        private String ref;
+        private int size;
+        private List<PushCommit> commits;
+
+        /**
+         * The SHA of the HEAD commit on the repository
+         */
+        public String getHead() {
+            return head;
+        }
+
+        /**
+         * This is undocumented, but it looks like this captures the commit that the ref was pointing to
+         * before the push.
+         */
+        public String getBefore() {
+            return before;
+        }
+
+        /**
+         * The full Git ref that was pushed. Example: “refs/heads/master”
+         */
+        public String getRef() {
+            return ref;
+        }
+
+        /**
+         * The number of commits in the push.
+         * Is this always the same as {@code getCommits().size()}?
+         */
+        public int getSize() {
+            return size;
+        }
+
+        /**
+         * The list of pushed commits.
+         */
+        public List<PushCommit> getCommits() {
+            return commits;
+        }
+
+        /**
+         * Commit in a push
+         */
+        public static class PushCommit {
+            private GitUser author;
+            private String url, sha, message;
+            private boolean distinct;
+
+            public GitUser getAuthor() {
+                return author;
+            }
+
+            /**
+             * Points to the commit API resource.
+             */
+            public String getUrl() {
+                return url;
+            }
+
+            public String getSha() {
+                return sha;
+            }
+
+            public String getMessage() {
+                return message;
+            }
+
+            /**
+             * Whether this commit is distinct from any that have been pushed before.
+             */
+            public boolean isDistinct() {
+                return distinct;
+            }
+        }
+    }
+}

src/main/java/org/kohsuke/github/GHGist.java

@@ -0,0 +1,200 @@
+package org.kohsuke.github;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Gist
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GHUser#listGists()
+ * @see GitHub#getGist(String)
+ * @see GitHub#createGist()
+ */
+public final class GHGist {
+    /*package almost final*/ GHUser owner;
+    /*package almost final*/ GitHub root;
+
+    private String url, forks_url, commits_url, id, git_pull_url, git_push_url, html_url;
+
+    @JsonProperty("public")
+    private boolean _public;
+
+    private String created_at, updated_at, description;
+
+    private int comments;
+
+    private String comments_url;
+
+    private Map<String,GHGistFile> files = new HashMap<String, GHGistFile>();
+
+    /**
+     * User that owns this Gist.
+     */
+    public GHUser getOwner() {
+        return owner;
+    }
+
+    /**
+     * API URL of this gist, such as 'https://api.github.com/gists/12345'
+     */
+    public String getUrl() {
+        return url;
+    }
+
+    public String getForksUrl() {
+        return forks_url;
+    }
+
+    public String getCommitsUrl() {
+        return commits_url;
+    }
+
+    /**
+     * ID of this gist, such as '12345'
+     */
+    public String getId() {
+        return id;
+    }
+
+    /**
+     * URL like https://gist.github.com/gists/12345.git
+     */
+    public String getGitPullUrl() {
+        return git_pull_url;
+    }
+
+    public String getGitPushUrl() {
+        return git_push_url;
+    }
+
+    public String getHtmlUrl() {
+        return html_url;
+    }
+
+    public boolean isPublic() {
+        return _public;
+    }
+
+    public Date getCreatedAt() {
+        return GitHub.parseDate(created_at);
+    }
+
+    public Date getUpdatedAt() {
+        return GitHub.parseDate(updated_at);
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public int getCommentCount() {
+        return comments;
+    }
+
+    /**
+     * API URL of listing comments.
+     */
+    public String getCommentsUrl() {
+        return comments_url;
+    }
+
+    public GHGistFile getFile(String name) {
+        return files.get(name);
+    }
+
+    public Map<String,GHGistFile> getFiles() {
+        return Collections.unmodifiableMap(files);
+    }
+
+    /*package*/ GHGist wrapUp(GHUser owner) {
+        this.owner = owner;
+        this.root = owner.root;
+        wrapUp();
+        return this;
+    }
+
+    /**
+     * Used when caller obtains {@link GHGist} without knowing its owner.
+     * A partially constructed owner object is interned.
+     */
+    /*package*/ GHGist wrapUp(GitHub root) throws IOException {
+        this.owner = root.getUser(owner);
+        this.root = root;
+        wrapUp();
+        return this;
+    }
+
+    private void wrapUp() {
+        for (Entry<String, GHGistFile> e : files.entrySet()) {
+            e.getValue().fileName = e.getKey();
+        }
+    }
+    String getApiTailUrl(String tail) {
+        return "/gists/" + id + '/' + tail;
+    }
+
+    public void star() throws IOException {
+        new Requester(root).method("PUT").to(getApiTailUrl("star"));
+    }
+
+    public void unstar() throws IOException {
+        new Requester(root).method("DELETE").to(getApiTailUrl("star"));
+    }
+
+    public boolean isStarred() throws IOException {
+        return root.retrieve().asHttpStatusCode(getApiTailUrl("star"))/100==2;
+    }
+
+    /**
+     * Forks this gist into your own.
+     */
+    public GHGist fork() throws IOException {
+        return new Requester(root).to(getApiTailUrl("forks"),GHGist.class).wrapUp(root);
+    }
+
+    public PagedIterable<GHGist> listForks() {
+        return new PagedIterable<GHGist>() {
+            public PagedIterator<GHGist> iterator() {
+                return new PagedIterator<GHGist>(root.retrieve().asIterator(getApiTailUrl("forks"), GHGist[].class)) {
+                    @Override
+                    protected void wrapUp(GHGist[] page) {
+                        try {
+                            for (GHGist c : page)
+                                c.wrapUp(root);
+                        } catch (IOException e) {
+                            throw new Error(e);
+                        }
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Deletes this gist.
+     */
+    public void delete() throws IOException {
+        new Requester(root).method("DELETE").to("/gists/" + id);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        GHGist ghGist = (GHGist) o;
+        return id.equals(ghGist.id);
+
+    }
+
+    @Override
+    public int hashCode() {
+        return id.hashCode();
+    }
+}

src/main/java/org/kohsuke/github/GHGistBuilder.java

@@ -0,0 +1,48 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+
+/**
+ * Builder pattern for creating a new Gist.
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GitHub#createGist()
+ */
+public class GHGistBuilder {
+    private final GitHub root;
+    private final Requester req;
+    private final LinkedHashMap<String,Object> files = new LinkedHashMap<String, Object>();
+
+    public GHGistBuilder(GitHub root) {
+        this.root = root;
+        req = new Requester(root);
+    }
+
+    public GHGistBuilder description(String desc) {
+        req.with("description",desc);
+        return this;
+    }
+
+    public GHGistBuilder public_(boolean v) {
+        req.with("public",v);
+        return this;
+    }
+
+    /**
+     * Adds a new file.
+     */
+    public GHGistBuilder file(String fileName, String content) {
+        files.put(fileName, Collections.singletonMap("content", content));
+        return this;
+    }
+
+    /**
+     * Creates a Gist based on the parameters specified thus far.
+     */
+    public GHGist create() throws IOException {
+        req._with("files",files);
+        return req.to("/gists",GHGist.class).wrapUp(root);
+    }
+}

src/main/java/org/kohsuke/github/GHGistFile.java

@@ -0,0 +1,60 @@
+package org.kohsuke.github;
+
+/**
+ * A file inside {@link GHGist}
+ *
+ * @author Kohsuke Kawaguchi
+ * @see GHGist#getFile(String)
+ * @see GHGist#getFiles()
+ */
+public class GHGistFile {
+    /*package almost final*/ String fileName;
+
+    private int size;
+    private String raw_url, type, language, content;
+    private boolean truncated;
+
+
+    public String getFileName() {
+        return fileName;
+    }
+
+    /**
+     * File size in bytes.
+     */
+    public int getSize() {
+        return size;
+    }
+
+    /**
+     * URL that serves this file as-is.
+     */
+    public String getRawUrl() {
+        return raw_url;
+    }
+
+    /**
+     * Content type of this Gist, such as "text/plain"
+     */
+    public String getType() {
+        return type;
+    }
+
+    public String getLanguage() {
+        return language;
+    }
+
+    /**
+     * Content of this file.
+     */
+    public String getContent() {
+        return content;
+    }
+
+    /**
+     * (?) indicates if {@link #getContent()} contains a truncated content.
+     */
+    public boolean isTruncated() {
+        return truncated;
+    }
+}

src/main/java/org/kohsuke/github/GHHook.java

@@ -34,7 +34,7 @@ public final class GHHook {
     public EnumSet<GHEvent> getEvents() {
         EnumSet<GHEvent> s = EnumSet.noneOf(GHEvent.class);
         for (String e : events)
-            Enum.valueOf(GHEvent.class,e.toUpperCase(Locale.ENGLISH));
+            s.add(Enum.valueOf(GHEvent.class,e.toUpperCase(Locale.ENGLISH)));
         return s;
     }
 
@@ -54,7 +54,6 @@ public final class GHHook {
      * Deletes this hook.
      */
     public void delete() throws IOException {
-        new Poster(repository.root,ApiVersion.V3).withCredential()
-                .to(String.format("/repos/%s/%s/hooks/%d",repository.getOwnerName(),repository.getName(),id),null,"DELETE");
+        new Requester(repository.root).method("DELETE").to(String.format("/repos/%s/%s/hooks/%d", repository.getOwnerName(), repository.getName(), id));
     }
 }

src/main/java/org/kohsuke/github/GHIssue.java

@@ -30,6 +30,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.List;
+import java.util.Locale;
 
 /**
  * Represents an issue on GitHub.
@@ -40,11 +41,56 @@ import java.util.List;
 public class GHIssue {
     GitHub root;
     GHRepository owner;
+	
+	// API v3
+    protected GHUser assignee;
+    protected String state;
+    protected int number;
+    protected String closed_at;
+    protected int comments;
+    protected String body;
+    protected List<Label> labels;
+    protected GHUser user;
+    protected String title, created_at, html_url;
+    protected GHIssue.PullRequest pull_request;
+    protected GHMilestone milestone;
+	protected String url, updated_at;
+    protected int id;
+    protected GHUser closed_by;
 
-    private String gravatar_id,body,title,state,created_at,updated_at,html_url;
-    private List<String> labels;
-    private int number,votes,comments;
-    private int position;
+    public static class Label {
+        private String url;
+        private String name;
+        private String color;
+		
+        public String getUrl() {
+			return url;
+		}
+		
+        public String getName() {
+			return name;
+		}
+		
+        public String getColor() {
+			return color;
+		}
+    }
+    
+    /*package*/ GHIssue wrap(GHRepository owner) {
+        this.owner = owner;
+        this.root = owner.root;
+		if(milestone != null) milestone.wrap(owner);
+		if(assignee != null) assignee.wrapUp(root);
+		if(user != null) user.wrapUp(root);
+		if(closed_by != null) closed_by.wrapUp(root);
+        return this;
+    }
+
+    /*package*/ static GHIssue[] wrap(GHIssue[] issues, GHRepository owner) {
+        for (GHIssue i : issues)
+            i.wrap(owner);
+        return issues;
+    }
 
     /**
      * Repository to which the issue belongs.
@@ -80,10 +126,13 @@ public class GHIssue {
     }
 
     public GHIssueState getState() {
-        return Enum.valueOf(GHIssueState.class, state);
+        return Enum.valueOf(GHIssueState.class, state.toUpperCase(Locale.ENGLISH));
     }
 
-    public Collection<String> getLabels() {
+    public Collection<Label> getLabels() {
+        if(labels == null){
+            return Collections.EMPTY_LIST;
+        }
         return Collections.unmodifiableList(labels);
     }
 
@@ -95,35 +144,132 @@ public class GHIssue {
         return GitHub.parseDate(updated_at);
     }
 
+    public Date getClosedAt() {
+        return GitHub.parseDate(closed_at);
+    }
+
+	public URL getApiURL(){
+        return GitHub.parseURL(url);
+	}
+
     /**
      * Updates the issue by adding a comment.
      */
     public void comment(String message) throws IOException {
-        new Poster(root).withCredential().with("comment",message).to(getApiRoute("comment"));
+        new Requester(root).with("body",message).to(getIssuesApiRoute() + "/comments");
+    }
+
+    private void edit(String key, Object value) throws IOException {
+        new Requester(root)._with(key, value).method("PATCH").to(getApiRoute());
     }
 
     /**
      * Closes this issue.
      */
     public void close() throws IOException {
-        new Poster(root).withCredential().to(getApiRoute("close"));
+        edit("state", "closed");
     }
 
     /**
      * Reopens this issue.
      */
     public void reopen() throws IOException {
-        new Poster(root).withCredential().to(getApiRoute("reopen"));
+        edit("state", "open");
+    }
+
+    public void setTitle(String title) throws IOException {
+        edit("title",title);
+    }
+
+    public void setBody(String body) throws IOException {
+        edit("body",body);
+    }
+
+    public void assignTo(GHUser user) throws IOException {
+        edit("assignee",user.getLogin());
+    }
+
+    public void setLabels(String... labels) throws IOException {
+        edit("labels",labels);
     }
 
     /**
      * Obtains all the comments associated with this issue.
+	 * 
+	 * @see #listComments() 
      */
-    public List<GHIssueComment> getComments() throws IOException {
-        return root.retrieve(getApiRoute("comments"), JsonIssueComments.class).wrap(this);
+	public List<GHIssueComment> getComments() throws IOException {
+		return listComments().asList();
+	}
+	
+	/**
+	 * Obtains all the comments associated with this issue.
+	 */
+    public PagedIterable<GHIssueComment> listComments() throws IOException {
+        return new PagedIterable<GHIssueComment>() {
+            public PagedIterator<GHIssueComment> iterator() {
+                return new PagedIterator<GHIssueComment>(root.retrieve().asIterator(getIssuesApiRoute() + "/comments", GHIssueComment[].class)) {
+                    protected void wrapUp(GHIssueComment[] page) {
+                        for (GHIssueComment c : page)
+                            c.wrapUp(GHIssue.this);
+                    }
+                };
+            }
+        };
     }
 
-    private String getApiRoute(String verb) {
-        return "/issues/"+verb+"/"+owner.getOwnerName()+"/"+owner.getName()+"/"+number;
+    protected String getApiRoute() {
+        return getIssuesApiRoute();
     }
-}
+
+    private String getIssuesApiRoute() {
+        return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/issues/"+number;
+    }
+
+	public GHUser getAssignee() {
+		return assignee;
+	}
+	
+    /**
+     * User who submitted the issue.
+     */
+	public GHUser getUser() {
+        return user;
+	}
+	
+	public GHUser getClosedBy() {
+		if(!"closed".equals(state)) return null;
+		if(closed_by != null) return closed_by;
+		
+		//TODO closed_by = owner.getIssue(number).getClosed_by();
+		return closed_by;
+	}
+	
+	public int getCommentsCount(){
+		return comments;
+	}
+
+	public PullRequest getPullRequest() {
+		return pull_request;
+	}
+
+	public GHMilestone getMilestone() {
+		return milestone;
+	}
+
+	public static class PullRequest{
+		private String diff_url, patch_url, html_url;
+		
+		public URL getDiffUrl() {
+			return GitHub.parseURL(diff_url);
+		}
+		
+		public URL getPatchUrl() {
+			return GitHub.parseURL(patch_url);
+		}
+		
+		public URL getUrl() {
+			return GitHub.parseURL(html_url);
+		}
+	}
+}

src/main/java/org/kohsuke/github/GHIssueBuilder.java

@@ -0,0 +1,59 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Kohsuke Kawaguchi
+ */
+public class GHIssueBuilder {
+    private final GHRepository repo;
+    private final Requester builder;
+    private List<String> labels = new ArrayList<String>();
+
+    GHIssueBuilder(GHRepository repo, String title) {
+        this.repo = repo;
+        this.builder = new Requester(repo.root);
+        builder.with("title",title);
+    }
+
+    /**
+     * Sets the main text of an issue, which is arbitrary multi-line text.
+     */
+    public GHIssueBuilder body(String str) {
+        builder.with("body",str);
+        return this;
+    }
+
+    public GHIssueBuilder assignee(GHUser user) {
+        if (user!=null)
+            builder.with("assignee",user.getLogin());
+        return this;
+    }
+
+    public GHIssueBuilder assignee(String user) {
+        if (user!=null)
+            builder.with("assignee",user);
+        return this;
+    }
+
+    public GHIssueBuilder milestone(GHMilestone milestone) {
+        if (milestone!=null)
+            builder.with("milestone",milestone.getNumber());
+        return this;
+    }
+
+    public GHIssueBuilder label(String label) {
+        if (label!=null)
+            labels.add(label);
+        return this;
+    }
+
+    /**
+     * Creates a new issue.
+     */
+    public GHIssue create() throws IOException {
+        return builder.with("labels",labels).to(repo.getApiTailUrl("issues"),GHIssue.class).wrap(repo);
+    }
+}

src/main/java/org/kohsuke/github/GHIssueComment.java

@@ -24,6 +24,7 @@
 package org.kohsuke.github;
 
 import java.io.IOException;
+import java.net.URL;
 import java.util.Date;
 
 /**
@@ -34,8 +35,15 @@ import java.util.Date;
 public class GHIssueComment {
     GHIssue owner;
 
-    private String body, gravatar_id, user, created_at, updated_at;
+    private String body, gravatar_id, created_at, updated_at;
+    private URL url;
     private int id;
+    private GHUser user;
+
+    /*package*/ GHIssueComment wrapUp(GHIssue owner) {
+        this.owner = owner;
+        return this;
+    }
 
     /**
      * Gets the issue to which this comment is associated.
@@ -63,17 +71,22 @@ public class GHIssueComment {
         return id;
     }
 
+    public URL getUrl() {
+        return url;
+    }
+
     /**
      * Gets the ID of the user who posted this comment.
      */
+    @Deprecated
     public String getUserName() {
-        return user;
+        return user.getLogin();
     }
 
     /**
      * Gets the user who posted this comment.
      */
     public GHUser getUser() throws IOException {
-        return owner.root.getUser(user);
+        return owner.root.getUser(user.getLogin());
     }
 }

src/main/java/org/kohsuke/github/GHKey.java

@@ -0,0 +1,48 @@
+package org.kohsuke.github;
+
+import org.apache.commons.lang.builder.ToStringBuilder;
+
+/**
+ * SSH public key.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public class GHKey {
+    /*package almost final*/ GitHub root;
+
+    protected String url, key, title;
+    protected boolean verified;
+    protected int id;
+
+    public int getId() {
+        return id;
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    /**
+     * Something like "https://api.github.com/user/keys/73593"
+     */
+    public String getUrl() {
+        return url;
+    }
+
+    public boolean isVerified() {
+        return verified;
+    }
+
+    /*package*/ GHKey wrap(GitHub root) {
+        this.root = root;
+        return this;
+    }
+
+    public String toString() {
+        return new ToStringBuilder(this).append("title",title).append("id",id).append("key",key).toString();
+    }
+}

src/main/java/org/kohsuke/github/GHMilestone.java

@@ -0,0 +1,89 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.util.Date;
+import java.util.Locale;
+
+/**
+ * 
+ * @author Yusuke Kokubo
+ *
+ */
+public class GHMilestone {
+    GitHub root;
+	GHRepository owner;
+
+	GHUser creator;
+	private String state, due_on, title, url, created_at, description;
+	private int closed_issues, open_issues, number;
+
+	public GitHub getRoot() {
+		return root;
+	}
+	
+	public GHRepository getOwner() {
+		return owner;
+	}
+	
+	public GHUser getCreator() {
+		return creator;
+	}
+	
+	public Date getDueOn() {
+		if (due_on == null) return null;
+		return GitHub.parseDate(due_on);
+	}
+	
+	public String getTitle() {
+		return title;
+	}
+	
+	public String getUrl() {
+		return url;
+	}
+	
+	public Date getCreatedAt() {
+		return GitHub.parseDate(created_at);
+	}
+	
+	public String getDescription() {
+		return description;
+	}
+	
+	public int getClosedIssues() {
+		return closed_issues;
+	}
+	
+	public int getOpenIssues() {
+		return open_issues;
+	}
+	
+	public int getNumber() {
+		return number;
+	}
+	
+	public GHMilestoneState getState() {
+		return Enum.valueOf(GHMilestoneState.class, state.toUpperCase(Locale.ENGLISH));
+	}
+
+    /**
+     * Closes this issue.
+     */
+    public void close() throws IOException {
+        edit("state", "closed");
+    }
+
+    private void edit(String key, Object value) throws IOException {
+        new Requester(root)._with(key, value).method("PATCH").to(getApiRoute());
+    }
+
+    protected String getApiRoute() {
+        return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/milestones/"+number;
+    }
+
+	public GHMilestone wrap(GHRepository repo) {
+		this.owner = repo;
+		this.root = repo.root;
+		return this;
+	}
+}

src/main/java/org/kohsuke/github/GHMilestoneState.java

@@ -0,0 +1,11 @@
+package org.kohsuke.github;
+
+/**
+ * 
+ * @author Yusuke Kokubo
+ *
+ */
+public enum GHMilestoneState {
+    OPEN,
+    CLOSED
+}

src/main/java/org/kohsuke/github/GHMyself.java

@@ -0,0 +1,132 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+/**
+ * Represents the account that's logging into GitHub.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public class GHMyself extends GHUser {
+    /**
+     * @deprecated
+     *      Use {@link #getEmails2()}
+     */
+    public List<String> getEmails() throws IOException {
+        List<GHEmail> src = getEmails2();
+        List<String> r = new ArrayList<String>(src.size());
+        for (GHEmail e : src) {
+            r.add(e.getEmail());
+        }
+        return r;
+    }
+
+    /**
+     * Returns the read-only list of e-mail addresses configured for you.
+     *
+     * This corresponds to the stuff you configure in https://github.com/settings/emails,
+     * and not to be confused with {@link #getEmail()} that shows your public e-mail address
+     * set in https://github.com/settings/profile
+     *
+     * @return
+     *      Always non-null.
+     */
+    public List<GHEmail> getEmails2() throws IOException {
+        GHEmail[] addresses = root.retrieve().to("/user/emails", GHEmail[].class);
+        return Collections.unmodifiableList(Arrays.asList(addresses));
+    }
+
+    /**
+     * Returns the read-only list of all the pulic keys of the current user.
+     *
+     * NOTE: When using OAuth authenticaiton, the READ/WRITE User scope is
+     * required by the GitHub APIs, otherwise you will get a 404 NOT FOUND.
+     *
+     * @return
+     *      Always non-null.
+     */
+    public List<GHKey> getPublicKeys() throws IOException {
+        return Collections.unmodifiableList(Arrays.asList(root.retrieve().to("/user/keys", GHKey[].class)));
+    }
+
+    /**
+     * Returns the read-only list of all the public verified keys of the current user.
+     *
+     * Differently from the getPublicKeys() method, the retrieval of the user's
+     * verified public keys does not require any READ/WRITE OAuth Scope to the
+     * user's profile.
+     *
+     * @return
+     *      Always non-null.
+     */
+  public List<GHVerifiedKey> getPublicVerifiedKeys() throws IOException {
+    return Collections.unmodifiableList(Arrays.asList(root.retrieve().to(
+        "/users/" + getLogin() + "/keys", GHVerifiedKey[].class)));
+  }
+
+    /**
+     * Gets the organization that this user belongs to.
+     */
+    public GHPersonSet<GHOrganization> getAllOrganizations() throws IOException {
+        GHPersonSet<GHOrganization> orgs = new GHPersonSet<GHOrganization>();
+        Set<String> names = new HashSet<String>();
+        for (GHOrganization o : root.retrieve().to("/user/orgs", GHOrganization[].class)) {
+            if (names.add(o.getLogin()))    // in case of rumoured duplicates in the data
+                orgs.add(root.getOrganization(o.getLogin()));
+        }
+        return orgs;
+    }
+
+    /**
+     * Gets the all repositories this user owns (public and private).
+     */
+    public synchronized Map<String,GHRepository> getAllRepositories() throws IOException {
+        Map<String,GHRepository> repositories = new TreeMap<String, GHRepository>();
+        for (GHRepository r : listAllRepositories()) {
+            repositories.put(r.getName(),r);
+        }
+        return Collections.unmodifiableMap(repositories);
+    }
+
+    /**
+     * Lists up all repositories this user owns (public and private).
+     *
+     * Unlike {@link #getAllRepositories()}, this does not wait until all the repositories are returned.
+     */
+    @Override
+    public PagedIterable<GHRepository> listRepositories() {
+        return new PagedIterable<GHRepository>() {
+            public PagedIterator<GHRepository> iterator() {
+                return new PagedIterator<GHRepository>(root.retrieve().asIterator("/user/repos", GHRepository[].class)) {
+                    @Override
+                    protected void wrapUp(GHRepository[] page) {
+                        for (GHRepository c : page)
+                            c.wrap(root);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * @deprecated
+     *      Use {@link #listRepositories()}
+     */
+    public PagedIterable<GHRepository> listAllRepositories() {
+        return listRepositories();
+    }
+
+//    public void addEmails(Collection<String> emails) throws IOException {
+////        new Requester(root,ApiVersion.V3).withCredential().to("/user/emails");
+//        root.retrieveWithAuth3()
+//    }
+}

src/main/java/org/kohsuke/github/GHOrganization.java

@@ -1,24 +1,21 @@
 package org.kohsuke.github;
 
-import com.gargoylesoftware.htmlunit.WebClient;
-import com.gargoylesoftware.htmlunit.html.HtmlAnchor;
-import com.gargoylesoftware.htmlunit.html.HtmlPage;
-
-import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
-
-import static org.kohsuke.github.ApiVersion.*;
+import java.util.TreeMap;
 
 /**
  * @author Kohsuke Kawaguchi
  */
 public class GHOrganization extends GHPerson {
+    /*package*/ GHOrganization wrapUp(GitHub root) {
+        return (GHOrganization)super.wrapUp(root);
+    }
+
     /**
      * Creates a new repository.
      *
@@ -26,12 +23,17 @@ public class GHOrganization extends GHPerson {
      *      Newly created repository.
      */
     public GHRepository createRepository(String name, String description, String homepage, String team, boolean isPublic) throws IOException {
-        return createRepository(name,description,homepage,getTeams().get(team),isPublic);
+        GHTeam t = getTeams().get(team);
+        if (t==null)
+            throw new IllegalArgumentException("No such team: "+team);
+        return createRepository(name,description,homepage,t,isPublic);
     }
 
     public GHRepository createRepository(String name, String description, String homepage, GHTeam team, boolean isPublic) throws IOException {
+        if (team==null)
+            throw new IllegalArgumentException("Invalid team");
         // such API doesn't exist, so fall back to HTML scraping
-        return new Poster(root,V3).withCredential()
+        return new Requester(root)
                 .with("name", name).with("description", description).with("homepage", homepage)
                 .with("public", isPublic).with("team_id",team.getId()).to("/orgs/"+login+"/repos", GHRepository.class).wrap(root);
     }
@@ -40,15 +42,70 @@ public class GHOrganization extends GHPerson {
      * Teams by their names.
      */
     public Map<String,GHTeam> getTeams() throws IOException {
-        return root.retrieveWithAuth("/organizations/"+login+"/teams",JsonTeams.class).toMap(this);
+        Map<String,GHTeam> r = new TreeMap<String, GHTeam>();
+        for (GHTeam t : listTeams()) {
+            r.put(t.getName(),t);
+        }
+        return r;
     }
 
-    @Override
-    public GHRepository getRepository(String name) throws IOException {
+    /**
+     * List up all the teams.
+     */
+    public PagedIterable<GHTeam> listTeams() throws IOException {
+        return new PagedIterable<GHTeam>() {
+            public PagedIterator<GHTeam> iterator() {
+                return new PagedIterator<GHTeam>(root.retrieve().asIterator(String.format("/orgs/%s/teams", login), GHTeam[].class)) {
+                    @Override
+                    protected void wrapUp(GHTeam[] page) {
+                        for (GHTeam c : page)
+                            c.wrapUp(GHOrganization.this);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Finds a team that has the given name in its {@link GHTeam#getName()}
+     */
+    public GHTeam getTeamByName(String name) throws IOException {
+        for (GHTeam t : listTeams()) {
+            if(t.getName().equals(name))
+                return t;
+        }
+        return null;
+    }
+
+    /**
+     * Checks if this organization has the specified user as a member.
+     */
+    public boolean hasMember(GHUser user) {
         try {
-            return root.retrieveWithAuth3("/repos/" + login + '/' + name, GHRepository.class).wrap(root);
-        } catch (FileNotFoundException e) {
-            return null;
+            root.retrieve().to("/orgs/" + login + "/members/"  + user.getLogin());
+            return true;
+        } catch (IOException ignore) {
+            return false;
+        }
+    }
+
+    /**
+     * Remove a member of the organisation - which will remove them from
+     * all teams, and remove their access to the organization’s repositories.
+     */
+    public void remove(GHUser user) throws IOException {
+        root.retrieve().method("DELETE").to("/orgs/" + login + "/members/"  + user.getLogin());
+    }
+
+    /**
+     * Checks if this organization has the specified user as a public member.
+     */
+    public boolean hasPublicMember(GHUser user) {
+        try {
+            root.retrieve().to("/orgs/" + login + "/public_members/" + user.getLogin());
+            return true;
+        } catch (IOException ignore) {
+            return false;
         }
     }
 
@@ -56,30 +113,48 @@ public class GHOrganization extends GHPerson {
      * Publicizes the membership.
      */
     public void publicize(GHUser u) throws IOException {
-        root.retrieveWithAuth3("/orgs/" + login + "/public_members/" + u.getLogin(), null, "PUT");
+        root.retrieve().method("PUT").to("/orgs/" + login + "/public_members/" + u.getLogin(), null);
+    }
+
+    /**
+     * @deprecated use {@link #listMembers()}
+     */
+    public List<GHUser> getMembers() throws IOException {
+        return listMembers().asList();
     }
 
     /**
      * All the members of this organization.
      */
-    public List<GHUser> getMembers() throws IOException {
-        return new AbstractList<GHUser>() {
-            // these are shallow objects with only some limited values filled out
-            // TODO: it's better to allow objects to fill themselves in later when missing values are requested
-            final GHUser[] shallow = root.retrieveWithAuth3("/orgs/" + login + "/members", GHUser[].class);
+    public PagedIterable<GHUser> listMembers() throws IOException {
+        return listMembers("members");
+    }
 
-            @Override
-            public GHUser get(int index) {
-                try {
-                    return root.getUser(shallow[index].getLogin());
-                } catch (IOException e) {
-                    throw new RuntimeException(e);
-                }
-            }
+    /**
+     * All the public members of this organization.
+     */
+    public PagedIterable<GHUser> listPublicMembers() throws IOException {
+        return listMembers("public_members");
+    }
 
-            @Override
-            public int size() {
-                return shallow.length;
+    private PagedIterable<GHUser> listMembers(String suffix) throws IOException {
+        return listMembers(suffix, null);
+    }
+
+    public PagedIterable<GHUser> listMembersWithFilter(String filter) throws IOException {
+        return listMembers("members", filter);
+    }
+
+    private PagedIterable<GHUser> listMembers(final String suffix, final String filter) throws IOException {
+        return new PagedIterable<GHUser>() {
+            public PagedIterator<GHUser> iterator() {
+                String filterParams = (filter == null) ? "" : ("?filter=" + filter);
+                return new PagedIterator<GHUser>(root.retrieve().asIterator(String.format("/orgs/%s/%s%s", login, suffix, filterParams), GHUser[].class)) {
+                    @Override
+                    protected void wrapUp(GHUser[] users) {
+                        GHUser.wrap(users, root);
+                    }
+                };
             }
         };
     }
@@ -88,7 +163,7 @@ public class GHOrganization extends GHPerson {
      * Conceals the membership.
      */
     public void conceal(GHUser u) throws IOException {
-        root.retrieveWithAuth3("/orgs/" + login + "/public_members/" + u.getLogin(), null, "DELETE");
+        root.retrieve().method("DELETE").to("/orgs/" + login + "/public_members/" + u.getLogin(), null);
     }
 
     public enum Permission { ADMIN, PUSH, PULL }
@@ -97,11 +172,13 @@ public class GHOrganization extends GHPerson {
      * Creates a new team and assigns the repositories.
      */
     public GHTeam createTeam(String name, Permission p, Collection<GHRepository> repositories) throws IOException {
-        Poster post = new Poster(root).withCredential().with("team[name]", name).with("team[permission]", p.name().toLowerCase());
+        Requester post = new Requester(root).with("name", name).with("permission", p.name().toLowerCase());
+        List<String> repo_names = new ArrayList<String>();
         for (GHRepository r : repositories) {
-            post.with("team[repo_names][]",r.getOwnerName()+'/'+r.getName());
+            repo_names.add(r.getName());
         }
-        return post.to("/organizations/"+login+"/teams",JsonTeam.class).wrap(this);
+        post.with("repo_names",repo_names);
+        return post.method("POST").to("/orgs/" + login + "/teams", GHTeam.class).wrapUp(this);
     }
 
     public GHTeam createTeam(String name, Permission p, GHRepository... repositories) throws IOException {
@@ -110,15 +187,18 @@ public class GHOrganization extends GHPerson {
 
     /**
      * List up repositories that has some open pull requests.
+     *
+     * This used to be an efficient method that didn't involve traversing every repository, but now
+     * it doesn't do any optimization.
      */
     public List<GHRepository> getRepositoriesWithOpenPullRequests() throws IOException {
-        WebClient wc = root.createWebClient();
-        HtmlPage pg = (HtmlPage)wc.getPage("https://github.com/organizations/"+login+"/dashboard/pulls");
         List<GHRepository> r = new ArrayList<GHRepository>();
-        for (HtmlAnchor e : pg.getElementById("js-issue-list").<HtmlAnchor>selectNodes(".//UL[@class='smallnav']/LI[not(@class='zeroed')]/A")) {
-            String a = e.getHrefAttribute();
-            String name = a.substring(a.lastIndexOf('/')+1);
-            r.add(getRepository(name));
+        for (GHRepository repository : listRepositories()) {
+            repository.wrap(root);
+            List<GHPullRequest> pullRequests = repository.getPullRequests(GHIssueState.OPEN);
+            if (pullRequests.size() > 0) {
+                r.add(repository);
+            }
         }
         return r;
     }
@@ -133,4 +213,43 @@ public class GHOrganization extends GHPerson {
         }
         return all;
     }
+
+    /**
+     * Lists events performed by a user (this includes private events if the caller is authenticated.
+     */
+    public PagedIterable<GHEventInfo> listEvents() throws IOException {
+        return new PagedIterable<GHEventInfo>() {
+            public PagedIterator<GHEventInfo> iterator() {
+                return new PagedIterator<GHEventInfo>(root.retrieve().asIterator(String.format("/orgs/%s/events", login), GHEventInfo[].class)) {
+                    @Override
+                    protected void wrapUp(GHEventInfo[] page) {
+                        for (GHEventInfo c : page)
+                            c.wrapUp(root);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Lists up all the repositories using the specified page size.
+     *
+     * @param pageSize size for each page of items returned by GitHub. Maximum page size is 100.
+     *
+     * Unlike {@link #getRepositories()}, this does not wait until all the repositories are returned.
+     */
+    @Override
+    public PagedIterable<GHRepository> listRepositories(final int pageSize) {
+        return new PagedIterable<GHRepository>() {
+            public PagedIterator<GHRepository> iterator() {
+                return new PagedIterator<GHRepository>(root.retrieve().asIterator("/orgs/" + login + "/repos?per_page=" + pageSize, GHRepository[].class)) {
+                    @Override
+                    protected void wrapUp(GHRepository[] page) {
+                        for (GHRepository c : page)
+                            c.wrap(root);
+                    }
+                };
+            }
+        };
+    }
 }

src/main/java/org/kohsuke/github/GHPerson.java

@@ -2,7 +2,10 @@ package org.kohsuke.github;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 
@@ -14,35 +17,114 @@ import java.util.TreeMap;
 public abstract class GHPerson {
     /*package almost final*/ GitHub root;
 
-    // common
-    protected String login,location,blog,email,name,created_at,company;
+    // core data fields that exist even for "small" user data (such as the user info in pull request)
+    protected String login, avatar_url, url, gravatar_id;
     protected int id;
-    protected String gravatar_id; // appears in V3 as well but presumably subsumed by avatar_url?
 
-    // V2
-    protected int public_gist_count,public_repo_count,followers_count,following_count;
-
-    // V3
-    protected String avatar_url,html_url;
+    // other fields (that only show up in full data)
+    protected String location,blog,email,name,created_at,company;
+    protected String html_url;
     protected int followers,following,public_repos,public_gists;
 
+    /*package*/ GHPerson wrapUp(GitHub root) {
+        this.root = root;
+        return this;
+    }
+
     /**
-     * Gets the repositories this user owns.
+     * Fully populate the data by retrieving missing data.
+     *
+     * Depending on the original API call where this object is created, it may not contain everything.
+     */
+    protected void populate() throws IOException {
+        if (created_at!=null)    return; // already populated
+
+        root.retrieve().to(url, this);
+    }
+
+    /**
+     * Gets the public repositories this user owns.
+     *
+     * <p>
+     * To list your own repositories, including private repositories,
+     * use {@link GHMyself#listRepositories()}
      */
     public synchronized Map<String,GHRepository> getRepositories() throws IOException {
         Map<String,GHRepository> repositories = new TreeMap<String, GHRepository>();
-        for (int i=1; ; i++) {
-            GHRepository[] array = root.retrieve3("/users/" + login + "/repos?per_page=100&page=" + i, GHRepository[].class);
-            for (GHRepository r : array) {
-                r.root = root;
-                repositories.put(r.getName(),r);
-            }
-            if (array.length==0)  break;
+        for (GHRepository r : listRepositories()) {
+            repositories.put(r.getName(),r);
         }
-
         return Collections.unmodifiableMap(repositories);
     }
 
+    /**
+     * Lists up all the repositories using a 30 items page size.
+     *
+     * Unlike {@link #getRepositories()}, this does not wait until all the repositories are returned.
+     */
+    public PagedIterable<GHRepository> listRepositories() {
+      return listRepositories(30);
+    }
+
+    /**
+     * Lists up all the repositories using the specified page size.
+     *
+     * @param pageSize size for each page of items returned by GitHub. Maximum page size is 100.
+     *
+     * Unlike {@link #getRepositories()}, this does not wait until all the repositories are returned.
+     */
+    public PagedIterable<GHRepository> listRepositories(final int pageSize) {
+        return new PagedIterable<GHRepository>() {
+            public PagedIterator<GHRepository> iterator() {
+                return new PagedIterator<GHRepository>(root.retrieve().asIterator("/users/" + login + "/repos?per_page=" + pageSize, GHRepository[].class)) {
+                    @Override
+                    protected void wrapUp(GHRepository[] page) {
+                        for (GHRepository c : page)
+                            c.wrap(root);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Loads repository list in a pagenated fashion.
+     * 
+     * <p>
+     * For a person with a lot of repositories, GitHub returns the list of repositories in a pagenated fashion.
+     * Unlike {@link #getRepositories()}, this method allows the caller to start processing data as it arrives.
+     * 
+     * Every {@link Iterator#next()} call results in I/O. Exceptions that occur during the processing is wrapped
+     * into {@link Error}.
+     *
+     * @deprecated
+     *      Use {@link #listRepositories()}
+     */
+    public synchronized Iterable<List<GHRepository>> iterateRepositories(final int pageSize) {
+        return new Iterable<List<GHRepository>>() {
+            public Iterator<List<GHRepository>> iterator() {
+                final Iterator<GHRepository[]> pager = root.retrieve().asIterator("/users/" + login + "/repos?per_page="+pageSize,GHRepository[].class);
+
+                return new Iterator<List<GHRepository>>() {
+                    public boolean hasNext() {
+                        return pager.hasNext();
+                    }
+
+                    public List<GHRepository> next() {
+                        GHRepository[] batch = pager.next();
+                        for (GHRepository r : batch)
+                            r.root = root;
+                        return Arrays.asList(batch);
+                    }
+
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+                };
+            }
+        };
+    }
+
     /**
      *
      * @return
@@ -50,19 +132,39 @@ public abstract class GHPerson {
      */
     public GHRepository getRepository(String name) throws IOException {
         try {
-            return root.retrieve3("/repos/" + login + '/' + name, GHRepository.class).wrap(root);
+            return root.retrieve().to("/repos/" + login + '/' + name, GHRepository.class).wrap(root);
         } catch (FileNotFoundException e) {
             return null;
         }
     }
 
+    /**
+     * Lists events for an organization or an user.
+     */
+    public abstract PagedIterable<GHEventInfo> listEvents() throws IOException;
+
     /**
      * Gravatar ID of this user, like 0cb9832a01c22c083390f3c5dcb64105
+     *
+     * @deprecated
+     *      No longer available in the v3 API.
      */
     public String getGravatarId() {
         return gravatar_id;
     }
 
+    /**
+     * Returns a string like 'https://secure.gravatar.com/avatar/0cb9832a01c22c083390f3c5dcb64105'
+     * that indicates the avatar image URL.
+     */
+    public String getAvatarUrl() {
+        if (avatar_url!=null)
+            return avatar_url;
+        if (gravatar_id!=null)
+            return "https://secure.gravatar.com/avatar/"+gravatar_id;
+        return null;
+    }
+
     /**
      * Gets the login ID of this user, like 'kohsuke'
      */
@@ -73,52 +175,65 @@ public abstract class GHPerson {
     /**
      * Gets the human-readable name of the user, like "Kohsuke Kawaguchi"
      */
-    public String getName() {
+    public String getName() throws IOException {
+        populate();
         return name;
     }
 
     /**
      * Gets the company name of this user, like "Sun Microsystems, Inc."
      */
-    public String getCompany() {
+    public String getCompany() throws IOException {
+        populate();
         return company;
     }
 
     /**
      * Gets the location of this user, like "Santa Clara, California"
      */
-    public String getLocation() {
+    public String getLocation() throws IOException {
+        populate();
         return location;
     }
 
-    public String getCreatedAt() {
+    public String getCreatedAt() throws IOException {
+        populate();
         return created_at;
     }
 
     /**
      * Gets the blog URL of this user.
      */
-    public String getBlog() {
+    public String getBlog() throws IOException {
+        populate();
         return blog;
     }
 
+    public String getHtmlUrl() {
+        return html_url;
+    }
+
     /**
      * Gets the e-mail address of the user.
      */
-    public String getEmail() {
+    public String getEmail() throws IOException {
+        populate();
         return email;
     }
 
-    public int getPublicGistCount() {
-        return Math.max(public_gist_count,public_gists);
+    public int getPublicGistCount() throws IOException {
+        populate();
+        return public_gists;
     }
 
-    public int getPublicRepoCount() {
-        return Math.max(public_repo_count,public_repos);
+    public int getPublicRepoCount() throws IOException {
+        populate();
+        return public_repos;
     }
 
-    public int getFollowingCount() {
-        return Math.max(following_count,following);
+    public int getFollowingCount() throws IOException {
+        populate();
+        return following;
     }
 
     /**
@@ -128,8 +243,8 @@ public abstract class GHPerson {
         return id;
     }
 
-    public int getFollowersCount() {
-        return Math.max(followers_count,followers);
+    public int getFollowersCount() throws IOException {
+        populate();
+        return followers;
     }
-
 }

src/main/java/org/kohsuke/github/GHPersonSet.java

@@ -1,5 +1,6 @@
 package org.kohsuke.github;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 
@@ -16,6 +17,10 @@ public final class GHPersonSet<T extends GHPerson> extends HashSet<T> {
         super(c);
     }
 
+    public GHPersonSet(T... c) {
+        super(Arrays.asList(c));
+    }
+
     public GHPersonSet(int initialCapacity, float loadFactor) {
         super(initialCapacity, loadFactor);
     }

src/main/java/org/kohsuke/github/GHPullRequest.java

@@ -23,7 +23,9 @@
  */
 package org.kohsuke.github;
 
+import java.io.IOException;
 import java.net.URL;
+import java.util.Collection;
 import java.util.Date;
 import java.util.Locale;
 
@@ -31,14 +33,43 @@ import java.util.Locale;
  * A pull request.
  * 
  * @author Kohsuke Kawaguchi
+ * @see GHRepository#getPullRequest(int)
  */
 @SuppressWarnings({"UnusedDeclaration"})
 public class GHPullRequest extends GHIssue {
-    private String closed_at, patch_url, issue_updated_at;
-    private GHUser issue_user, user;
-    // labels??
-    private GHCommitPointer base, head;
-    private String mergeable, diff_url;
+	
+	private String patch_url, diff_url, issue_url;
+	private GHCommitPointer base;
+	private String merged_at;
+	private GHCommitPointer head;
+
+    // details that are only available when obtained from ID
+    private GHUser merged_by;
+   	private int review_comments, additions;
+   	private boolean merged;
+   	private Boolean mergeable;
+   	private int deletions;
+   	private String mergeable_state;
+   	private int changed_files;
+
+
+	GHPullRequest wrapUp(GHRepository owner) {
+		this.wrap(owner);
+        return wrapUp(owner.root);
+    }
+	
+    GHPullRequest wrapUp(GitHub root) {
+        if (owner!=null)    owner.wrap(root);
+        if (base!=null)     base.wrapUp(root);
+        if (head!=null)     head.wrapUp(root);
+        if (merged_by != null) merged_by.wrapUp(root);
+        return this;
+    }
+
+    @Override
+    protected String getApiRoute() {
+        return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/pulls/"+number;
+    }
 
     /**
      * The URL of the patch file.
@@ -47,12 +78,13 @@ public class GHPullRequest extends GHIssue {
     public URL getPatchUrl() {
         return GitHub.parseURL(patch_url);
     }
-
-    /**
-     * User who submitted a pull request.
+	
+	/**
+     * The URL of the patch file.
+     * like https://github.com/jenkinsci/jenkins/pull/100.patch
      */
-    public GHUser getUser() {
-        return user;
+    public URL getIssueUrl() {
+        return GitHub.parseURL(issue_url);
     }
 
     /**
@@ -64,22 +96,15 @@ public class GHPullRequest extends GHIssue {
     }
 
     /**
-     * The change that should be pulled.
+     * The change that should be pulled. The tip of the commits to merge.
      */
     public GHCommitPointer getHead() {
         return head;
     }
 
+	@Deprecated
     public Date getIssueUpdatedAt() {
-        return GitHub.parseDate(issue_updated_at);
-    }
-
-    /**
-     * The HTML page of this pull request,
-     * like https://github.com/jenkinsci/jenkins/pull/100
-     */
-    public URL getUrl() {
-        return super.getUrl();
+        return super.getUpdatedAt();
     }
 
     /**
@@ -90,7 +115,107 @@ public class GHPullRequest extends GHIssue {
         return GitHub.parseURL(diff_url);
     }
 
-    public Date getClosedAt() {
-        return GitHub.parseDate(closed_at);
+    public Date getMergedAt() {
+        return GitHub.parseDate(merged_at);
     }
+
+	@Override
+	public Collection<Label> getLabels() {
+		return super.getLabels();
+	}
+
+	@Override
+	public GHUser getClosedBy() {
+		return null;
+	}
+
+	@Override
+	public PullRequest getPullRequest() {
+		return null;
+	}
+
+//
+// details that are only available via get with ID
+//
+//
+    public GHUser getMergedBy() throws IOException {
+        populate();
+   		return merged_by;
+   	}
+
+   	public int getReviewComments() throws IOException {
+        populate();
+   		return review_comments;
+   	}
+
+   	public int getAdditions() throws IOException {
+        populate();
+   		return additions;
+   	}
+
+    public boolean isMerged() throws IOException {
+        populate();
+   		return merged;
+   	}
+
+   	public Boolean getMergeable() throws IOException {
+        populate();
+   		return mergeable;
+   	}
+
+   	public int getDeletions() throws IOException {
+        populate();
+   		return deletions;
+   	}
+
+   	public String getMergeableState() throws IOException {
+        populate();
+   		return mergeable_state;
+   	}
+
+   	public int getChangedFiles() throws IOException {
+        populate();
+   		return changed_files;
+   	}
+
+    /**
+     * Fully populate the data by retrieving missing data.
+     *
+     * Depending on the original API call where this object is created, it may not contain everything.
+     */
+    private void populate() throws IOException {
+        if (merged_by!=null)    return; // already populated
+
+        root.retrieve().to(url, this);
+    }
+
+    /**
+     * Retrieves all the commits associated to this pull request.
+     */
+    public PagedIterable<GHPullRequestCommitDetail> listCommits() {
+        return new PagedIterable<GHPullRequestCommitDetail>() {
+            public PagedIterator<GHPullRequestCommitDetail> iterator() {
+                return new PagedIterator<GHPullRequestCommitDetail>(root.retrieve().asIterator(
+                        String.format("%s/commits", getApiURL().getPath()),
+                        GHPullRequestCommitDetail[].class)) {
+                    @Override
+                    protected void wrapUp(GHPullRequestCommitDetail[] page) {
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Merge this pull request.
+     *
+     * The equivalent of the big green "Merge pull request" button.
+     *
+     * @param msg
+     *      Commit message. If null, the default one will be used.
+     */
+    public void merge(String msg) throws IOException {
+        new Requester(root).method("PUT").with("commit_message",msg).to(getApiRoute()+"/merge");
+    }
+
 }

src/main/java/org/kohsuke/github/GHPullRequestCommitDetail.java

@@ -0,0 +1,129 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2013, Luca Milanesio
+ * 
+ * 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.
+ */
+package org.kohsuke.github;
+
+import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
+
+import java.net.URL;
+
+/**
+ * Commit detail inside a {@link GHPullRequest}.
+ * 
+ * @author Luca Milanesio
+ */
+public class GHPullRequestCommitDetail {
+
+    /**
+     * @deprecated Use {@link GitUser}
+     */
+    public static class Authorship extends GitUser {}
+
+    public static class Tree {
+    String sha;
+    String url;
+
+    public String getSha() {
+      return sha;
+    }
+
+    public URL getUrl() {
+      return GitHub.parseURL(url);
+    }
+  }
+
+  public static class Commit {
+    Authorship author;
+    Authorship committer;
+    String message;
+    Tree tree;
+    String url;
+    int comment_count;
+
+    @WithBridgeMethods(value=Authorship.class,castRequired=true)
+    public GitUser getAuthor() {
+      return author;
+    }
+
+    @WithBridgeMethods(value=Authorship.class,castRequired=true)
+    public GitUser getCommitter() {
+      return committer;
+    }
+
+    public String getMessage() {
+      return message;
+    }
+
+    public URL getUrl() {
+      return GitHub.parseURL(url);
+    }
+
+    public int getComment_count() {
+      return comment_count;
+    }
+  }
+
+  public static class CommitPointer {
+    String sha;
+    String url;
+    String html_url;
+
+    public URL getUrl() {
+      return GitHub.parseURL(url);
+    }
+
+    public URL getHtml_url() {
+      return GitHub.parseURL(html_url);
+    }
+
+    public String getSha() {
+      return sha;
+    }
+  }
+
+  String sha;
+  Commit commit;
+  String url;
+  String html_url;
+  String comments_url;
+  CommitPointer[] parents;
+  
+  public String getSha() {
+    return sha;
+  }
+  public Commit getCommit() {
+    return commit;
+  }
+  public URL getApiUrl() {
+    return GitHub.parseURL(url);
+  }
+  public URL getUrl() {
+    return GitHub.parseURL(html_url);
+  }
+  public URL getCommentsUrl() {
+    return GitHub.parseURL(comments_url);
+  }
+  public CommitPointer[] getParents() {
+    return parents;
+  }
+}

src/main/java/org/kohsuke/github/GHRateLimit.java

@@ -0,0 +1,21 @@
+package org.kohsuke.github;
+
+/**
+ * Rate limit.
+ * @author Kohsuke Kawaguchi
+ */
+public class GHRateLimit {
+    /**
+     * Remaining calls that can be made.
+     */
+    public int remaining;
+    /**
+     * Alotted API call per hour.
+     */
+    public int limit;
+
+    @Override
+    public String toString() {
+        return remaining+"/"+limit;
+    }
+}

src/main/java/org/kohsuke/github/GHRef.java

@@ -0,0 +1,61 @@
+package org.kohsuke.github;
+
+import java.net.URL;
+
+/**
+ * Provides information on a Git ref from GitHub.
+ *
+ * @author Michael Clarke
+ */
+public class GHRef {
+
+    private String ref, url;
+    private GHObject object;
+
+    /**
+     * Name of the ref, such as "refs/tags/abc"
+     */
+    public String getRef() {
+        return ref;
+    }
+
+    /**
+     * The API URL of this tag, such as https://api.github.com/repos/jenkinsci/jenkins/git/refs/tags/1.312
+     */
+    public URL getUrl() {
+        return GitHub.parseURL(url);
+    }
+
+    /**
+     * The object that this ref points to.
+     */
+    public GHObject getObject() {
+        return object;
+    }
+
+
+    public static class GHObject {
+         private String type, sha, url;
+
+        /**
+         * Type of the object, such as "commit"
+         */
+        public String getType() {
+            return type;
+        }
+
+        /**
+         * SHA1 of this object.
+         */
+        public String getSha() {
+            return sha;
+        }
+
+        /**
+         * API URL to this Git data, such as https://api.github.com/repos/jenkinsci/jenkins/git/commits/b72322675eb0114363a9a86e9ad5a170d1d07ac0
+         */
+        public URL getUrl() {
+            return GitHub.parseURL(url);
+        }
+    }
+}

src/main/java/org/kohsuke/github/GHRelease.java

@@ -0,0 +1,224 @@
+package org.kohsuke.github;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+import static java.lang.String.format;
+
+/**
+ * Release in a github repository.
+ *
+ * @see GHRepository#getReleases()
+ * @see GHRepository#createRelease(String)
+ */
+public class GHRelease {
+    GitHub root;
+    GHRepository owner;
+
+    private String url;
+    private String html_url;
+    private String assets_url;
+    private String upload_url;
+    private long id;
+    private String tag_name;
+    private String target_commitish;
+    private String name;
+    private String body;
+    private boolean draft;
+    private boolean prerelease;
+    private Date created_at;
+    private Date published_at;
+    private String tarball_url;
+    private String zipball_url;
+
+    public String getAssetsUrl() {
+        return assets_url;
+    }
+
+    public void setAssetsUrl(String assets_url) {
+        this.assets_url = assets_url;
+    }
+
+    public String getBody() {
+        return body;
+    }
+
+    public void setBody(String body) {
+        this.body = body;
+    }
+
+    public Date getCreatedAt() {
+        return created_at;
+    }
+
+    public void setCreatedAt(Date created_at) {
+        this.created_at = created_at;
+    }
+
+    public boolean isDraft() {
+        return draft;
+    }
+
+    public void setDraft(boolean draft) {
+        this.draft = draft;
+    }
+
+    public String getHtmlUrl() {
+        return html_url;
+    }
+
+    public void setHtmlUrl(String html_url) {
+        this.html_url = html_url;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public GHRepository getOwner() {
+        return owner;
+    }
+
+    public void setOwner(GHRepository owner) {
+        this.owner = owner;
+    }
+
+    public boolean isPrerelease() {
+        return prerelease;
+    }
+
+    public void setPrerelease(boolean prerelease) {
+        this.prerelease = prerelease;
+    }
+
+    public Date getPublished_at() {
+        return published_at;
+    }
+
+    public void setPublished_at(Date published_at) {
+        this.published_at = published_at;
+    }
+
+    public GitHub getRoot() {
+        return root;
+    }
+
+    public void setRoot(GitHub root) {
+        this.root = root;
+    }
+
+    public String getTagName() {
+        return tag_name;
+    }
+
+    public void setTagName(String tag_name) {
+        this.tag_name = tag_name;
+    }
+
+    public String getTargetCommitish() {
+        return target_commitish;
+    }
+
+    public void setTargetCommitish(String target_commitish) {
+        this.target_commitish = target_commitish;
+    }
+
+    public String getUploadUrl() {
+        return upload_url;
+    }
+
+    public void setUploadUrl(String upload_url) {
+        this.upload_url = upload_url;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getZipballUrl() {
+        return zipball_url;
+    }
+
+    public void setZipballUrl(String zipballUrl) {
+        this.zipball_url = zipballUrl;
+    }
+
+    public String getTarballUrl() {
+        return tarball_url;
+    }
+
+    public void setTarballUrl(String tarballUrl) {
+        this.tarball_url = tarballUrl;
+    }
+
+    GHRelease wrap(GHRepository owner) {
+        this.owner = owner;
+        this.root = owner.root;
+        return this;
+    }
+
+    static GHRelease[] wrap(GHRelease[] releases, GHRepository owner) {
+        for (GHRelease release : releases) {
+            release.wrap(owner);
+        }
+        return releases;
+    }
+
+    /**
+     * Because github relies on SNI (http://en.wikipedia.org/wiki/Server_Name_Indication) this method will only work on
+     * Java 7 or greater.  Options for fixing this for earlier JVMs can be found here
+     * http://stackoverflow.com/questions/12361090/server-name-indication-sni-on-java but involve more complicated
+     * handling of the HTTP requests to github's API.
+     *
+     * @throws IOException
+     */
+    public GHAsset uploadAsset(File file, String contentType) throws IOException {
+        Requester builder = new Requester(owner.root);
+
+        String url = format("https://uploads.github.com%sreleases/%d/assets?name=%s",
+                owner.getApiTailUrl(""), getId(), file.getName());
+        return builder.contentType(contentType)
+                .with(new FileInputStream(file))
+                .to(url, GHAsset.class).wrap(this);
+    }
+
+    public List<GHAsset> getAssets() throws IOException {
+        Requester builder = new Requester(owner.root);
+
+        GHAsset[] assets = builder
+                .method("GET")
+                .to(getApiTailUrl("assets"), GHAsset[].class);
+        return Arrays.asList(GHAsset.wrap(assets, this));
+    }
+
+    /**
+     * Deletes this release.
+     */
+    public void delete() throws IOException {
+        new Requester(root).method("DELETE").to(owner.getApiTailUrl("releases/"+id));
+    }
+
+    private String getApiTailUrl(String end) {
+        return owner.getApiTailUrl(format("releases/%s/%s",id,end));
+    }
+}

src/main/java/org/kohsuke/github/GHReleaseBuilder.java

@@ -0,0 +1,80 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+
+/**
+ * Builder pattern for creating a {@link GHRelease}
+ *
+ * @see GHRepository#createRelease(String)
+ */
+public class GHReleaseBuilder {
+    private final GHRepository repo;
+    private final Requester builder;
+
+    public GHReleaseBuilder(GHRepository ghRepository, String tag) {
+        this.repo = ghRepository;
+        this.builder = new Requester(repo.root);
+        builder.with("tag_name", tag);
+    }
+
+    /**
+     * @param body The release notes body.
+     */
+    public GHReleaseBuilder body(String body) {
+        if (body != null) {
+            builder.with("body", body);
+        }
+        return this;
+    }
+
+    /**
+     * Specifies the commitish value that determines where the Git tag is created from. Can be any branch or
+     * commit SHA.
+     *
+     * @param commitish Defaults to the repository’s default branch (usually "master"). Unused if the Git tag
+     *                  already exists.
+     * @return
+     */
+    public GHReleaseBuilder commitish(String commitish) {
+        if (commitish != null) {
+            builder.with("target_commitish", commitish);
+        }
+        return this;
+    }
+
+    /**
+     * Optional.
+     *
+     * @param draft {@code true} to create a draft (unpublished) release, {@code false} to create a published one.
+     *                          Default is {@code false}.
+     */
+    public GHReleaseBuilder draft(boolean draft) {
+        builder.with("draft", draft);
+        return this;
+    }
+
+    /**
+     * @param name the name of the release
+     */
+    public GHReleaseBuilder name(String name) {
+        if (name != null) {
+            builder.with("name", name);
+        }
+        return this;
+    }
+
+    /**
+     * Optional
+     *
+     * @param prerelease {@code true} to identify the release as a prerelease. {@code false} to identify the release
+     *                               as a full release. Default is {@code false}.
+     */
+    public GHReleaseBuilder prerelease(boolean prerelease) {
+        builder.with("prerelease", prerelease);
+        return this;
+    }
+
+    public GHRelease create() throws IOException {
+        return builder.to(repo.getApiTailUrl("releases"), GHRelease.class).wrap(repo);
+    }
+}

src/main/java/org/kohsuke/github/GHRepository.java

@@ -23,18 +23,12 @@
  */
 package org.kohsuke.github;
 
-import com.gargoylesoftware.htmlunit.ElementNotFoundException;
-import com.gargoylesoftware.htmlunit.WebClient;
-import com.gargoylesoftware.htmlunit.html.HtmlButton;
-import com.gargoylesoftware.htmlunit.html.HtmlCheckBoxInput;
-import com.gargoylesoftware.htmlunit.html.HtmlForm;
-import com.gargoylesoftware.htmlunit.html.HtmlInput;
-import com.gargoylesoftware.htmlunit.html.HtmlPage;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
 
+import javax.xml.bind.DatatypeConverter;
 import java.io.IOException;
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
+import java.io.InterruptedIOException;
 import java.net.URL;
 import java.util.AbstractSet;
 import java.util.ArrayList;
@@ -42,15 +36,16 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeMap;
 
 import static java.util.Arrays.*;
-import static org.kohsuke.github.ApiVersion.V3;
 
 /**
  * A repository on GitHub.
@@ -64,10 +59,24 @@ public class GHRepository {
     private String description, homepage, name;
     private String url; // this is the API url
     private String html_url;    // this is the UI
+    private String git_url, ssh_url, clone_url, svn_url;
     private GHUser owner;   // not fully populated. beware.
-    private boolean has_issues, has_wiki, fork, _private, has_downloads;
-    private int watchers,forks,open_issues;
+    private boolean has_issues, has_wiki, fork, has_downloads;
+    @JsonProperty("private")
+    private boolean _private;
+    private int watchers,forks,open_issues,size,network_count,subscribers_count;
     private String created_at, pushed_at;
+    private Map<Integer,GHMilestone> milestones = new HashMap<Integer, GHMilestone>();
+    
+    private String default_branch,language;
+    private Map<String,GHCommit> commits = new HashMap<String, GHCommit>();
+
+    private GHRepoPermission permissions;
+
+    private static class GHRepoPermission {
+        boolean pull,push,admin;
+    }
+
 
     public String getDescription() {
         return description;
@@ -78,22 +87,161 @@ public class GHRepository {
     }
 
     /**
-     * URL of this repository, like 'http://github.com/kohsuke/hudson'
+     * URL of this repository, like 'http://github.com/kohsuke/jenkins'
      */
     public String getUrl() {
         return html_url;
     }
 
+    /**
+     * Gets the git:// URL to this repository, such as "git://github.com/kohsuke/jenkins.git"
+     * This URL is read-only.
+     */
+    public String getGitTransportUrl() {
+        return git_url;
+    }
+
+    /**
+     * Gets the HTTPS URL to this repository, such as "https://github.com/kohsuke/jenkins.git"
+     * This URL is read-only.
+     */
+    public String gitHttpTransportUrl() {
+        return clone_url;
+    }
+
+    /**
+     * Gets the Subversion URL to access this repository: https://github.com/rails/rails
+     */
+    public String getSvnUrl() {
+        return svn_url;
+    }
+
+    /**
+     * Gets the SSH URL to access this repository, such as git@github.com:rails/rails.git
+     */
+    public String getSshUrl() {
+        return ssh_url;
+    }
+
+    /**
+     * Short repository name without the owner. For example 'jenkins' in case of http://github.com/jenkinsci/jenkins
+     */
     public String getName() {
         return name;
     }
 
+    public boolean hasPullAccess() {
+        return permissions!=null && permissions.pull;
+    }
+
+    public boolean hasPushAccess() {
+        return permissions!=null && permissions.push;
+    }
+
+    public boolean hasAdminAccess() {
+        return permissions!=null && permissions.admin;
+    }
+
+    /**
+     * Gets the primary programming language.
+     */
+    public String getLanguage() {
+        return language;
+    }
+
     public GHUser getOwner() throws IOException {
         return root.getUser(owner.login);   // because 'owner' isn't fully populated
     }
 
+    public GHIssue getIssue(int id) throws IOException {
+        return root.retrieve().to("/repos/" + owner.login + "/" + name + "/issues/" + id, GHIssue.class).wrap(this);
+    }
+
+    public GHIssueBuilder createIssue(String title) {
+        return new GHIssueBuilder(this,title);
+    }
+
     public List<GHIssue> getIssues(GHIssueState state) throws IOException {
-       return root.retrieve("/issues/list/" + owner.login + "/" + name + "/" + state.toString().toLowerCase(), JsonIssues.class).wrap(this);
+        return listIssues(state).asList();
+    }
+
+    public List<GHIssue> getIssues(GHIssueState state, GHMilestone milestone) throws IOException {
+        return Arrays.asList(GHIssue.wrap(root.retrieve()
+                .to(String.format("/repos/%s/%s/issues?state=%s&milestone=%s", owner.login, name,
+                        state.toString().toLowerCase(), milestone == null ? "none" : "" + milestone.getNumber()),
+                        GHIssue[].class
+                ), this));
+    }
+
+    /**
+     * Lists up all the issues in this repository.
+     */
+    public PagedIterable<GHIssue> listIssues(final GHIssueState state) {
+        return new PagedIterable<GHIssue>() {
+            public PagedIterator<GHIssue> iterator() {
+                return new PagedIterator<GHIssue>(root.retrieve().asIterator(getApiTailUrl("issues?state="+state.toString().toLowerCase(Locale.ENGLISH)), GHIssue[].class)) {
+                    @Override
+                    protected void wrapUp(GHIssue[] page) {
+                        for (GHIssue c : page)
+                            c.wrap(GHRepository.this);
+                    }
+                };
+            }
+        };
+    }
+
+    public GHReleaseBuilder createRelease(String tag) {
+        return new GHReleaseBuilder(this,tag);
+    }
+
+    /**
+     * Creates a named ref, such as tag, branch, etc.
+     *
+     * @param name
+     *      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.
+     * @param sha
+     *      The SHA1 value to set this reference to
+     */
+    public GHRef createRef(String name, String sha) throws IOException {
+        return new Requester(root)
+                .with("ref", name).with("sha", sha).method("POST").to(getApiTailUrl("git/refs"), GHRef.class);
+    }
+
+    /**
+     * @deprecated
+     *      use {@link #listReleases()}
+     */
+    public List<GHRelease> getReleases() throws IOException {
+        return listReleases().asList();
+    }
+
+    public PagedIterable<GHRelease> listReleases() throws IOException {
+        return new PagedIterable<GHRelease>() {
+            public PagedIterator<GHRelease> iterator() {
+                return new PagedIterator<GHRelease>(root.retrieve().asIterator(getApiTailUrl("releases"), GHRelease[].class)) {
+                    @Override
+                    protected void wrapUp(GHRelease[] page) {
+                        for (GHRelease c : page)
+                            c.wrap(GHRepository.this);
+                    }
+                };
+            }
+        };
+    }
+
+    public PagedIterable<GHTag> listTags() throws IOException {
+        return new PagedIterable<GHTag>() {
+            public PagedIterator<GHTag> iterator() {
+                return new PagedIterator<GHTag>(root.retrieve().asIterator(getApiTailUrl("tags"), GHTag[].class)) {
+                    @Override
+                    protected void wrapUp(GHTag[] page) {
+                        for (GHTag c : page)
+                            c.wrap(GHRepository.this);
+                    }
+                };
+            }
+        };
     }
 
     protected String getOwnerName() {
@@ -132,6 +280,19 @@ public class GHRepository {
         return open_issues;
     }
 
+    public int getNetworkCount() {
+        return network_count;
+    }
+
+    public int getSubscribersCount() {
+        return subscribers_count;
+    }
+
+    /**
+     *
+     * @return
+     *      null if the repository was never pushed at.
+     */
     public Date getPushedAt() {
         return GitHub.parseDate(pushed_at);
     }
@@ -140,6 +301,19 @@ public class GHRepository {
         return GitHub.parseDate(created_at);
     }
 
+    /**
+     * Returns the primary branch you'll configure in the "Admin > Options" config page.
+     *
+     * @return
+     *      This field is null until the user explicitly configures the master branch.
+     */
+    public String getMasterBranch() {
+        return default_branch;
+    }
+
+    public int getSize() {
+        return size;
+    }
 
     /**
      * Gets the collaborators on this repository.
@@ -147,10 +321,7 @@ public class GHRepository {
      */
     @WithBridgeMethods(Set.class)
     public GHPersonSet<GHUser> getCollaborators() throws IOException {
-        GHPersonSet<GHUser> r = new GHPersonSet<GHUser>();
-        for (String u : root.retrieve("/repos/show/"+owner.login+"/"+name+"/collaborators",JsonCollaborators.class).collaborators)
-            r.add(root.getUser(u));
-        return r;
+        return new GHPersonSet<GHUser>(GHUser.wrap(root.retrieve().to("/repos/" + owner.login + "/" + name + "/collaborators", GHUser[].class),root));
     }
 
     /**
@@ -158,16 +329,17 @@ public class GHRepository {
      * This method deviates from the principle of this library but it works a lot faster than {@link #getCollaborators()}.
      */
     public Set<String> getCollaboratorNames() throws IOException {
-        Set<String> r = new HashSet<String>(root.retrieve("/repos/show/"+owner.login+"/"+name+"/collaborators",JsonCollaborators.class).collaborators);
-        return Collections.unmodifiableSet(r);
+        Set<String> r = new HashSet<String>();
+        for (GHUser u : GHUser.wrap(root.retrieve().to("/repos/" + owner.login + "/" + name + "/collaborators", GHUser[].class),root))
+            r.add(u.login);
+        return r;
     }
 
     /**
      * If this repository belongs to an organization, return a set of teams.
      */
     public Set<GHTeam> getTeams() throws IOException {
-        return Collections.unmodifiableSet(root.retrieveWithAuth("/repos/show/"+owner.login+"/"+name+"/teams",JsonTeams.class).toSet(
-                root.getOrganization(owner.login)));
+        return Collections.unmodifiableSet(new HashSet<GHTeam>(Arrays.asList(GHTeam.wrapUp(root.retrieve().to("/repos/" + owner.login + "/" + name + "/teams", GHTeam[].class), root.getOrganization(owner.login)))));
     }
 
     public void addCollaborators(GHUser... users) throws IOException {
@@ -175,7 +347,7 @@ public class GHRepository {
     }
 
     public void addCollaborators(Collection<GHUser> users) throws IOException {
-        modifyCollaborators(users, "/add/");
+        modifyCollaborators(users, "PUT");
     }
 
     public void removeCollaborators(GHUser... users) throws IOException {
@@ -183,53 +355,68 @@ public class GHRepository {
     }
 
     public void removeCollaborators(Collection<GHUser> users) throws IOException {
-        modifyCollaborators(users, "/remove/");
+        modifyCollaborators(users, "DELETE");
     }
 
-    private void modifyCollaborators(Collection<GHUser> users, String op) throws IOException {
+    private void modifyCollaborators(Collection<GHUser> users, String method) throws IOException {
         verifyMine();
         for (GHUser user : users) {
-            new Poster(root).withCredential().to("/repos/collaborators/"+name+ op +user.getLogin());
+            new Requester(root).method(method).to("/repos/" + owner.login + "/" + name + "/collaborators/" + user.getLogin());
         }
     }
 
     public void setEmailServiceHook(String address) throws IOException {
-        WebClient wc = root.createWebClient();
-        HtmlPage pg = (HtmlPage)wc.getPage(getUrl()+"/admin");
-        HtmlInput email = (HtmlInput)pg.getElementById("email_address");
-        email.setValueAttribute(address);
-        HtmlCheckBoxInput active = (HtmlCheckBoxInput)pg.getElementById("email[active]");
-        active.setChecked(true);
+        Map<String, String> config = new HashMap<String, String>();
+        config.put("address", address);
+        new Requester(root).method("POST").with("name", "email").with("config", config).with("active", "true")
+                .to(String.format("/repos/%s/%s/hooks", owner.login, name));
+    }
 
-        final HtmlForm f = email.getEnclosingFormOrDie();
-        f.submit((HtmlButton) f.getElementsByTagName("button").get(0));
+    private void edit(String key, String value) throws IOException {
+        Requester requester = new Requester(root);
+        if (!key.equals("name"))
+            requester.with("name", name);   // even when we don't change the name, we need to send it in
+        requester.with(key, value).method("PATCH").to("/repos/" + owner.login + "/" + name);
     }
 
     /**
      * Enables or disables the issue tracker for this repository.
      */
     public void enableIssueTracker(boolean v) throws IOException {
-        new Poster(root).withCredential().with("values[has_issues]",String.valueOf(v))
-                .to("/repos/show/" + owner.login + "/" + name);
+        edit("has_issues", String.valueOf(v));
     }
 
     /**
      * Enables or disables Wiki for this repository.
      */
     public void enableWiki(boolean v) throws IOException {
-        new Poster(root).withCredential().with("values[has_wiki]",String.valueOf(v))
-                .to("/repos/show/" + owner.login + "/" + name);
+        edit("has_wiki", String.valueOf(v));
+    }
+
+    public void enableDownloads(boolean v) throws IOException {
+        edit("has_downloads",String.valueOf(v));
+    }
+
+    /**
+     * Rename this repository.
+     */
+    public void renameTo(String name) throws IOException {
+        edit("name",name);
+    }
+
+    public void setDescription(String value) throws IOException {
+        edit("description",value);
+    }
+
+    public void setHomepage(String value) throws IOException {
+        edit("homepage",value);
     }
 
     /**
      * Deletes this repository.
      */
     public void delete() throws IOException {
-        Poster poster = new Poster(root).withCredential();
-        String url = "/repos/delete/" + owner.login +"/"+name;
-
-        DeleteToken token = poster.to(url, DeleteToken.class);
-        poster.with("delete_token",token.delete_token).to(url);
+        new Requester(root).method("DELETE").to("/repos/" + owner.login + "/" + name);
     }
 
     /**
@@ -239,7 +426,7 @@ public class GHRepository {
      *      Newly forked repository that belong to you.
      */
     public GHRepository fork() throws IOException {
-        return new Poster(root,V3).withCredential().to("/repos/" + owner.login + "/" + name + "/forks", GHRepository.class, "POST").wrap(root);
+        return new Requester(root).method("POST").to("/repos/" + owner.login + "/" + name + "/forks", GHRepository.class).wrap(root);
     }
 
     /**
@@ -249,55 +436,75 @@ public class GHRepository {
      *      Newly forked repository that belong to you.
      */
     public GHRepository forkTo(GHOrganization org) throws IOException {
-        new Poster(root, V3).withCredential().to(String.format("/repos/%s/%s/forks?org=%s",owner.login,name,org.getLogin()));
-        return org.getRepository(name);
-    }
+        new Requester(root).to(String.format("/repos/%s/%s/forks?org=%s", owner.login, name, org.getLogin()));
 
-    /**
-     * Rename this repository.
-     */
-    public void renameTo(String newName) throws IOException {
-        WebClient wc = root.createWebClient();
-        HtmlPage pg = (HtmlPage)wc.getPage(getUrl()+"/admin");
-        for (HtmlForm f : pg.getForms()) {
-            if (!f.getActionAttribute().endsWith("/rename"))  continue;
+        // this API is asynchronous. we need to wait for a bit
+        for (int i=0; i<10; i++) {
+            GHRepository r = org.getRepository(name);
+            if (r!=null)    return r;
             try {
-                f.getInputByName("name").setValueAttribute(newName);
-                f.submit((HtmlButton)f.getElementsByTagName("button").get(0));
-
-                // overwrite fields
-                final GHRepository r = getOwner().getRepository(newName);
-                for (Field fi : getClass().getDeclaredFields()) {
-                    if (Modifier.isStatic(fi.getModifiers()))   continue;
-                    fi.setAccessible(true);
-                    try {
-                        fi.set(this,fi.get(r));
-                    } catch (IllegalAccessException e) {
-                        throw (IllegalAccessError)new IllegalAccessError().initCause(e);
-                    }
-                }
-
-                return;
-            } catch (ElementNotFoundException e) {
-                // continue
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw (IOException)new InterruptedIOException().initCause(e);
             }
         }
-
-        throw new IllegalArgumentException("Either you don't have the privilege to rename "+owner.login+'/'+name+" or there's a bug in HTML scraping");
+        throw new IOException(this+" was forked into "+org.getLogin()+" but can't find the new repository");
     }
 
     /**
      * Retrieves a specified pull request.
      */
     public GHPullRequest getPullRequest(int i) throws IOException {
-        return root.retrieveWithAuth("/pulls/" + owner.login + '/' + name + "/" + i, JsonPullRequest.class).wrap(this);
+        return root.retrieve().to("/repos/" + owner.login + '/' + name + "/pulls/" + i, GHPullRequest.class).wrapUp(this);
+    }
+
+    /**
+     * Retrieves all the pull requests of a particular state.
+     *
+     * @see #listPullRequests(GHIssueState)
+     */
+    public List<GHPullRequest> getPullRequests(GHIssueState state) throws IOException {
+        return listPullRequests(state).asList();
     }
 
     /**
      * Retrieves all the pull requests of a particular state.
      */
-    public List<GHPullRequest> getPullRequests(GHIssueState state) throws IOException {
-        return root.retrieveWithAuth("/pulls/"+owner.login+'/'+name+"/"+state.name().toLowerCase(Locale.ENGLISH),JsonPullRequests.class).wrap(this);
+    public PagedIterable<GHPullRequest> listPullRequests(final GHIssueState state) {
+        return new PagedIterable<GHPullRequest>() {
+            public PagedIterator<GHPullRequest> iterator() {
+                return new PagedIterator<GHPullRequest>(root.retrieve().asIterator(String.format("/repos/%s/%s/pulls?state=%s", owner.login, name, state.name().toLowerCase(Locale.ENGLISH)), GHPullRequest[].class)) {
+                    @Override
+                    protected void wrapUp(GHPullRequest[] page) {
+                        for (GHPullRequest pr : page)
+                            pr.wrap(GHRepository.this);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Creates a new pull request.
+     *
+     * @param title
+     *      Required. The title of the pull request.
+     * @param head
+     *      Required. The name of the branch where your changes are implemented.
+     *      For cross-repository pull requests in the same network,
+     *      namespace head with a user like this: username:branch.
+     * @param base
+     *      Required. The name of the branch you want your changes pulled into.
+     *      This should be an existing branch on the current repository.
+     * @param body
+     *      The contents of the pull request. This is the markdown description
+     *      of a pull request.
+     */
+    public GHPullRequest createPullRequest(String title, String head, String base, String body) throws IOException {
+        return new Requester(root).with("title",title)
+                .with("head",head)
+                .with("base",base)
+                .with("body",body).to(getApiTailUrl("pulls"),GHPullRequest.class).wrapUp(this);
     }
 
     /**
@@ -305,14 +512,176 @@ public class GHRepository {
      */
     public List<GHHook> getHooks() throws IOException {
         List<GHHook> list = new ArrayList<GHHook>(Arrays.asList(
-                root.retrieveWithAuth3(String.format("/repos/%s/%s/hooks",owner.login,name),GHHook[].class)));
+                root.retrieve().to(String.format("/repos/%s/%s/hooks", owner.login, name), GHHook[].class)));
         for (GHHook h : list)
             h.wrap(this);
         return list;
     }
 
     public GHHook getHook(int id) throws IOException {
-        return root.retrieveWithAuth3(String.format("/repos/%s/%s/hooks/%d",owner.login,name,id),GHHook.class).wrap(this);
+        return root.retrieve().to(String.format("/repos/%s/%s/hooks/%d", owner.login, name, id), GHHook.class).wrap(this);
+    }
+
+    /**
+     * Gets a comparison between 2 points in the repository. This would be similar
+     * to calling <tt>git log id1...id2</tt> against a local repository.
+     * @param id1 an identifier for the first point to compare from, this can be a sha1 ID (for a commit, tag etc) or a direct tag name
+     * @param id2 an identifier for the second point to compare to. Can be the same as the first point.
+     * @return the comparison output
+     * @throws IOException on failure communicating with GitHub
+     */
+    public GHCompare getCompare(String id1, String id2) throws IOException {
+        GHCompare compare = root.retrieve().to(String.format("/repos/%s/%s/compare/%s...%s", owner.login, name, id1, id2), GHCompare.class);
+        return compare.wrap(this);
+    }
+
+    public GHCompare getCompare(GHCommit id1, GHCommit id2) throws IOException {
+        return getCompare(id1.getSHA1(), id2.getSHA1());
+    }
+
+    public GHCompare getCompare(GHBranch id1, GHBranch id2) throws IOException {
+        return getCompare(id1.getName(),id2.getName());
+    }
+
+    /**
+     * Retrieves all refs for the github repository.
+     * @return an array of GHRef elements coresponding with the refs in the remote repository.
+     * @throws IOException on failure communicating with GitHub
+     */
+    public GHRef[] getRefs() throws IOException {
+       return root.retrieve().to(String.format("/repos/%s/%s/git/refs", owner.login, name), GHRef[].class);
+    }
+
+    /**
+     * Retrienved all refs of the given type for the current GitHub repository.
+     * @param refType the type of reg to search for e.g. <tt>tags</tt> or <tt>commits</tt>
+     * @return an array of all refs matching the request type
+     * @throws IOException on failure communicating with GitHub, potentially due to an invalid ref type being requested
+     */
+    public GHRef[] getRefs(String refType) throws IOException {
+        return root.retrieve().to(String.format("/repos/%s/%s/git/refs/%s", owner.login, name, refType), GHRef[].class);
+    }
+    /**
+	 * Retrive a ref of the given type for the current GitHub repository.
+	 * 
+	 * @param refName
+	 *            eg: heads/branch
+	 * @return refs matching the request type
+	 * @throws IOException
+	 *             on failure communicating with GitHub, potentially due to an
+	 *             invalid ref type being requested
+	 */
+	public GHRef getRef(String refName) throws IOException {
+		return root.retrieve().to(String.format("/repos/%s/%s/git/refs/%s", owner.login, name, refName), GHRef.class);
+	}
+    /**
+     * Gets a commit object in this repository.
+     */
+    public GHCommit getCommit(String sha1) throws IOException {
+        GHCommit c = commits.get(sha1);
+        if (c==null) {
+            c = root.retrieve().to(String.format("/repos/%s/%s/commits/%s", owner.login, name, sha1), GHCommit.class).wrapUp(this);
+            commits.put(sha1,c);
+        }
+        return c;
+    }
+
+    /**
+     * Lists all the commits.
+     */
+    public PagedIterable<GHCommit> listCommits() {
+        return new PagedIterable<GHCommit>() {
+            public PagedIterator<GHCommit> iterator() {
+                return new PagedIterator<GHCommit>(root.retrieve().asIterator(String.format("/repos/%s/%s/commits", owner.login, name), GHCommit[].class)) {
+                    protected void wrapUp(GHCommit[] page) {
+                        for (GHCommit c : page)
+                            c.wrapUp(GHRepository.this);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Search commits by specifying filters through a builder pattern.
+     */
+    public GHCommitQueryBuilder queryCommits() {
+        return new GHCommitQueryBuilder(this);
+    }
+
+    /**
+     * Lists up all the commit comments in this repository.
+     */
+    public PagedIterable<GHCommitComment> listCommitComments() {
+        return new PagedIterable<GHCommitComment>() {
+            public PagedIterator<GHCommitComment> iterator() {
+                return new PagedIterator<GHCommitComment>(root.retrieve().asIterator(String.format("/repos/%s/%s/comments", owner.login, name), GHCommitComment[].class)) {
+                    @Override
+                    protected void wrapUp(GHCommitComment[] page) {
+                        for (GHCommitComment c : page)
+                            c.wrap(GHRepository.this);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Lists all the commit statues attached to the given commit, newer ones first.
+     */
+    public PagedIterable<GHCommitStatus> listCommitStatuses(final String sha1) throws IOException {
+        return new PagedIterable<GHCommitStatus>() {
+            public PagedIterator<GHCommitStatus> iterator() {
+                return new PagedIterator<GHCommitStatus>(root.retrieve().asIterator(String.format("/repos/%s/%s/statuses/%s", owner.login, name, sha1), GHCommitStatus[].class)) {
+                    @Override
+                    protected void wrapUp(GHCommitStatus[] page) {
+                        for (GHCommitStatus c : page)
+                            c.wrapUp(root);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Gets the last status of this commit, which is what gets shown in the UI.
+     */
+    public GHCommitStatus getLastCommitStatus(String sha1) throws IOException {
+        List<GHCommitStatus> v = listCommitStatuses(sha1).asList();
+        return v.isEmpty() ? null : v.get(0);
+    }
+
+    /**
+     * Creates a commit status
+     *
+     * @param targetUrl
+     *      Optional parameter that points to the URL that has more details.
+     * @param description
+     *      Optional short description.
+     */
+    public GHCommitStatus createCommitStatus(String sha1, GHCommitState state, String targetUrl, String description) throws IOException {
+        return new Requester(root)
+                .with("state", state.name().toLowerCase(Locale.ENGLISH))
+                .with("target_url", targetUrl)
+                .with("description", description)
+                .to(String.format("/repos/%s/%s/statuses/%s",owner.login,this.name,sha1),GHCommitStatus.class).wrapUp(root);
+    }
+
+    /**
+     * Lists repository events.
+     */
+    public PagedIterable<GHEventInfo> listEvents() throws IOException {
+        return new PagedIterable<GHEventInfo>() {
+            public PagedIterator<GHEventInfo> iterator() {
+                return new PagedIterator<GHEventInfo>(root.retrieve().asIterator(String.format("/repos/%s/%s/events", owner.login, name), GHEventInfo[].class)) {
+                    @Override
+                    protected void wrapUp(GHEventInfo[] page) {
+                        for (GHEventInfo c : page)
+                            c.wrapUp(root);
+                    }
+                };
+            }
+        };
     }
 
     /**
@@ -321,7 +690,7 @@ public class GHRepository {
      * TODO: produce type-safe binding
      * 
      * @param name
-     *      Type of the hook to be created.
+     *      Type of the hook to be created. See https://api.github.com/hooks for possible names.
      * @param config
      *      The configuration hash.
      * @param events
@@ -335,9 +704,8 @@ public class GHRepository {
                 ea.add(e.name().toLowerCase(Locale.ENGLISH));
         }
 
-        return new Poster(root,ApiVersion.V3)
-                .withCredential()
-                .with("name",name)
+        return new Requester(root)
+                .with("name", name)
                 .with("active", active)
                 ._with("config", config)
                 ._with("events",ea)
@@ -436,6 +804,138 @@ public class GHRepository {
         return this;
     }
 
+    /**
+     * Gets branches by {@linkplain GHBranch#getName() their names}.
+     */
+    public Map<String,GHBranch> getBranches() throws IOException {
+        Map<String,GHBranch> r = new TreeMap<String,GHBranch>();
+        for (GHBranch p : root.retrieve().to(getApiTailUrl("branches"), GHBranch[].class)) {
+            p.wrap(this);
+            r.put(p.getName(),p);
+        }
+        return r;
+    }
+
+    /**
+     * @deprecated
+     *      Use {@link #listMilestones(GHIssueState)}
+     */
+    public Map<Integer, GHMilestone> getMilestones() throws IOException {
+        Map<Integer,GHMilestone> milestones = new TreeMap<Integer, GHMilestone>();
+    	for (GHMilestone m : listMilestones(GHIssueState.OPEN)) {
+    		milestones.put(m.getNumber(), m);
+    	}
+    	return milestones;
+    }
+
+    /**
+     * Lists up all the milestones in this repository.
+     */
+    public PagedIterable<GHMilestone> listMilestones(final GHIssueState state) {
+        return new PagedIterable<GHMilestone>() {
+            public PagedIterator<GHMilestone> iterator() {
+                return new PagedIterator<GHMilestone>(root.retrieve().asIterator(getApiTailUrl("milestones?state="+state.toString().toLowerCase(Locale.ENGLISH)), GHMilestone[].class)) {
+                    @Override
+                    protected void wrapUp(GHMilestone[] page) {
+                        for (GHMilestone c : page)
+                            c.wrap(GHRepository.this);
+                    }
+                };
+            }
+        };
+    }
+
+	public GHMilestone getMilestone(int number) throws IOException {
+		GHMilestone m = milestones.get(number);
+		if (m == null) {
+            m = root.retrieve().to(getApiTailUrl("milestones/" + number), GHMilestone.class);
+    		m.owner = this;
+    		m.root = root;
+			milestones.put(m.getNumber(), m);
+		}
+		return m;
+	}
+
+    public GHContent getFileContent(String path) throws IOException {
+        return getFileContent(path, null);
+    }
+
+    public GHContent getFileContent(String path, String ref) throws IOException {
+        Requester requester = root.retrieve();
+        String target = String.format("/repos/%s/%s/contents/%s", owner.login, name, path);
+
+        if (ref != null)
+            target = target + "?ref=" + ref;
+
+        return requester.to(target, GHContent.class).wrap(this);
+    }
+
+    public List<GHContent> getDirectoryContent(String path) throws IOException {
+        return getDirectoryContent(path, null);
+    }
+
+    public List<GHContent> getDirectoryContent(String path, String ref) throws IOException {
+        Requester requester = root.retrieve();
+        String target = String.format("/repos/%s/%s/contents/%s", owner.login, name, path);
+
+        if (ref != null)
+            target = target + "?ref=" + ref;
+
+        GHContent[] files = requester.to(target, GHContent[].class);
+
+        GHContent.wrap(files, this);
+
+        return Arrays.asList(files);
+    }
+
+    public GHContent getReadme() throws Exception {
+        return getFileContent("readme");
+    }
+
+    public GHContentUpdateResponse createContent(String content, String commitMessage, String path) throws IOException {
+        return createContent(content, commitMessage, path, null);
+    }
+
+    public GHContentUpdateResponse createContent(String content, String commitMessage, String path, String branch) throws IOException {
+        Requester requester = new Requester(root)
+            .with("path", path)
+            .with("message", commitMessage)
+            .with("content", DatatypeConverter.printBase64Binary(content.getBytes()))
+            .method("PUT");
+
+        if (branch != null) {
+            requester.with("branch", branch);
+        }
+
+        GHContentUpdateResponse response = requester.to(getApiTailUrl("contents/" + path), GHContentUpdateResponse.class);
+
+        response.getContent().wrap(this);
+        response.getCommit().wrapUp(this);
+
+        return response;
+    }
+
+	public GHMilestone createMilestone(String title, String description) throws IOException {
+        return new Requester(root)
+                .with("title", title).with("description", description).method("POST").to(getApiTailUrl("milestones"), GHMilestone.class).wrap(this);
+	}
+	
+	public GHDeployKey addDeployKey(String title,String key) throws IOException {
+		 return new Requester(root)
+         .with("title", title).with("key", key).method("POST").to(getApiTailUrl("keys"), GHDeployKey.class).wrap(this);
+		
+	}
+	
+	public List<GHDeployKey> getDeployKeys() throws IOException{
+		 List<GHDeployKey> list = new ArrayList<GHDeployKey>(Arrays.asList(
+	                root.retrieve().to(String.format("/repos/%s/%s/keys", owner.login, name), GHDeployKey[].class)));
+	        for (GHDeployKey h : list)
+	            h.wrap(this);
+	        return list;	
+	}
+	
+	
+
     @Override
     public String toString() {
         return "Repository:"+owner.login+":"+name;
@@ -455,4 +955,8 @@ public class GHRepository {
         }
         return false;
     }
+
+    String getApiTailUrl(String tail) {
+        return "/repos/" + owner.login + "/" + name +'/'+tail;
+    }
 }

src/main/java/org/kohsuke/github/GHTag.java

@@ -0,0 +1,36 @@
+package org.kohsuke.github;
+
+/**
+ * Represents a tag in {@link GHRepository}
+ *
+ * @see GHRepository#listTags()
+ */
+public class GHTag {
+    private GHRepository owner;
+    private GitHub root;
+
+    private String name;
+    private GHCommit commit;
+
+    /*package*/ GHTag wrap(GHRepository owner) {
+        this.owner = owner;
+        this.root = owner.root;
+        return this;
+    }
+
+    public GHRepository getOwner() {
+        return owner;
+    }
+
+    public GitHub getRoot() {
+        return root;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public GHCommit getCommit() {
+        return commit;
+    }
+}

src/main/java/org/kohsuke/github/GHTeam.java

@@ -1,8 +1,11 @@
 package org.kohsuke.github;
 
 import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeMap;
 
 /**
  * A team in GitHub organization.
@@ -15,6 +18,18 @@ public class GHTeam {
 
     protected /*final*/ GHOrganization org;
 
+    /*package*/ GHTeam wrapUp(GHOrganization owner) {
+        this.org = owner;
+        return this;
+    }
+
+    /*package*/ static GHTeam[] wrapUp(GHTeam[] teams, GHOrganization owner) {
+        for (GHTeam t : teams) {
+            t.wrapUp(owner);
+        }
+        return teams;
+    }
+
     public String getName() {
         return name;
     }
@@ -31,33 +46,50 @@ public class GHTeam {
      * Retrieves the current members.
      */
     public Set<GHUser> getMembers() throws IOException {
-        return org.root.retrieveWithAuth(api("/members"),JsonUsersWithDetails.class).toSet(org.root);
+        return new HashSet<GHUser>(Arrays.asList(GHUser.wrap(org.root.retrieve().to(api("/members"), GHUser[].class), org.root)));
+    }
+
+    /**
+     * Checks if this team has the specified user as a member.
+     */
+    public boolean hasMember(GHUser user) {
+        try {
+            org.root.retrieve().to("/teams/" + id + "/members/"  + user.getLogin());
+            return true;
+        } catch (IOException ignore) {
+            return false;
+        }
     }
 
     public Map<String,GHRepository> getRepositories() throws IOException {
-        return org.root.retrieveWithAuth3(api("/repos"),JsonRepositories.class).wrap(org.root);
+        GHRepository[] repos = org.root.retrieve().to(api("/repos"), GHRepository[].class);
+        Map<String,GHRepository> m = new TreeMap<String, GHRepository>();
+        for (GHRepository r : repos) {
+            m.put(r.getName(),r.wrap(org.root));
+        }
+        return m;
     }
 
     /**
      * Adds a member to the team.
      */
     public void add(GHUser u) throws IOException {
-        org.root.retrieveWithAuth(api("/members?name="+u.getLogin()),null, "POST");
+        org.root.retrieve().method("PUT").to(api("/members/" + u.getLogin()), null);
     }
 
     /**
      * Removes a member to the team.
      */
     public void remove(GHUser u) throws IOException {
-        org.root.retrieveWithAuth(api("/members?name="+u.getLogin()),null, "DELETE");
+        org.root.retrieve().method("DELETE").to(api("/members/" + u.getLogin()), null);
     }
 
     public void add(GHRepository r) throws IOException {
-        org.root.retrieveWithAuth(api("/repositories?name="+r.getOwnerName()+'/'+r.getName()),null, "POST");
+        org.root.retrieve().method("PUT").to(api("/repos/" + r.getOwnerName() + '/' + r.getName()), null);
     }
 
     public void remove(GHRepository r) throws IOException {
-        org.root.retrieveWithAuth(api("/repositories?name="+r.getOwnerName()+'/'+r.getName()),null, "DELETE");
+        org.root.retrieve().method("DELETE").to(api("/repos/" + r.getOwnerName() + '/' + r.getName()), null);
     }
 
     private String api(String tail) {

src/main/java/org/kohsuke/github/GHUser.java

@@ -23,12 +23,11 @@
  */
 package org.kohsuke.github;
 
-import com.infradna.tool.bridge_method_injector.BridgeMethodsAdded;
 import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
 
 import java.io.IOException;
+import java.util.Arrays;
 import java.util.HashSet;
-import java.util.Map;
 import java.util.Set;
 
 /**
@@ -42,14 +41,14 @@ public class GHUser extends GHPerson {
      * Follow this user.
      */
     public void follow() throws IOException {
-        new Poster(root).withCredential().to("/user/follow/"+login);
+        new Requester(root).method("PUT").to("/user/following/" + login);
     }
 
     /**
      * Unfollow this user.
      */
     public void unfollow() throws IOException {
-        new Poster(root).withCredential().to("/user/unfollow/"+login);
+        new Requester(root).method("DELETE").to("/user/following/" + login);
     }
 
     /**
@@ -57,7 +56,8 @@ public class GHUser extends GHPerson {
      */
     @WithBridgeMethods(Set.class)
     public GHPersonSet<GHUser> getFollows() throws IOException {
-        return root.retrieve("/user/show/"+login+"/following",JsonUsers.class).toSet(root);
+        GHUser[] followers = root.retrieve().to("/users/" + login + "/following", GHUser[].class);
+        return new GHPersonSet<GHUser>(Arrays.asList(wrap(followers,root)));
     }
 
     /**
@@ -65,7 +65,35 @@ public class GHUser extends GHPerson {
      */
     @WithBridgeMethods(Set.class)
     public GHPersonSet<GHUser> getFollowers() throws IOException {
-        return root.retrieve("/user/show/"+login+"/followers",JsonUsers.class).toSet(root);
+        GHUser[] followers = root.retrieve().to("/users/" + login + "/followers", GHUser[].class);
+        return new GHPersonSet<GHUser>(Arrays.asList(wrap(followers,root)));
+    }
+
+    /**
+     * Returns true if this user belongs to the specified organization.
+     */
+    public boolean isMemberOf(GHOrganization org) {
+        return org.hasMember(this);
+    }
+
+    /**
+     * Returns true if this user belongs to the specified team.
+     */
+    public boolean isMemberOf(GHTeam team) {
+        return team.hasMember(this);
+    }
+
+    /**
+     * Returns true if this user belongs to the specified organization as a public member.
+     */
+    public boolean isPublicMemberOf(GHOrganization org) {
+        return org.hasPublicMember(this);
+    }
+
+    /*package*/ static GHUser[] wrap(GHUser[] users, GitHub root) {
+        for (GHUser f : users)
+            f.root = root;
+        return users;
     }
 
     /**
@@ -75,13 +103,47 @@ public class GHUser extends GHPerson {
     public GHPersonSet<GHOrganization> getOrganizations() throws IOException {
         GHPersonSet<GHOrganization> orgs = new GHPersonSet<GHOrganization>();
         Set<String> names = new HashSet<String>();
-        for (GHOrganization o : root.retrieve3("/users/"+login+"/orgs",GHOrganization[].class)) {
+        for (GHOrganization o : root.retrieve().to("/users/" + login + "/orgs", GHOrganization[].class)) {
             if (names.add(o.getLogin()))    // I've seen some duplicates in the data
                 orgs.add(root.getOrganization(o.getLogin()));
         }
         return orgs;
     }
 
+    /**
+     * Lists events performed by a user (this includes private events if the caller is authenticated.
+     */
+    public PagedIterable<GHEventInfo> listEvents() throws IOException {
+        return new PagedIterable<GHEventInfo>() {
+            public PagedIterator<GHEventInfo> iterator() {
+                return new PagedIterator<GHEventInfo>(root.retrieve().asIterator(String.format("/users/%s/events", login), GHEventInfo[].class)) {
+                    @Override
+                    protected void wrapUp(GHEventInfo[] page) {
+                        for (GHEventInfo c : page)
+                            c.wrapUp(root);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Lists Gists created by this user.
+     */
+    public PagedIterable<GHGist> listGists() throws IOException {
+        return new PagedIterable<GHGist>() {
+            public PagedIterator<GHGist> iterator() {
+                return new PagedIterator<GHGist>(root.retrieve().asIterator(String.format("/users/%s/gists", login), GHGist[].class)) {
+                    @Override
+                    protected void wrapUp(GHGist[] page) {
+                        for (GHGist c : page)
+                            c.wrapUp(GHUser.this);
+                    }
+                };
+            }
+        };
+    }
+
     @Override
     public String toString() {
         return "User:"+login;

src/main/java/org/kohsuke/github/GHVerifiedKey.java

@@ -0,0 +1,13 @@
+package org.kohsuke.github;
+
+public class GHVerifiedKey extends GHKey {
+
+  public GHVerifiedKey() {
+    this.verified = true;
+  }
+
+  @Override
+  public String getTitle() {
+    return (title == null ? "key-" + id : title);
+  }
+}

src/main/java/org/kohsuke/github/GitHub.java

@@ -23,34 +23,33 @@
  */
 package org.kohsuke.github;
 
-import com.gargoylesoftware.htmlunit.WebClient;
-import com.gargoylesoftware.htmlunit.html.HtmlForm;
-import com.gargoylesoftware.htmlunit.html.HtmlPage;
-import org.apache.commons.io.IOUtils;
-import org.codehaus.jackson.map.DeserializationConfig.Feature;
-import org.codehaus.jackson.map.ObjectMapper;
-import org.codehaus.jackson.map.introspect.VisibilityChecker.Std;
-import sun.misc.BASE64Encoder;
+import static com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility.*;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.InterruptedIOException;
-import java.net.HttpURLConnection;
+import java.io.Reader;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Properties;
+import java.util.TimeZone;
 
-import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.*;
-import static org.kohsuke.github.ApiVersion.*;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.io.IOUtils;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.introspect.VisibilityChecker.Std;
+import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
 
 /**
  * Root of the GitHub API.
@@ -59,38 +58,80 @@ import static org.kohsuke.github.ApiVersion.*;
  */
 public class GitHub {
     /*package*/ final String login;
+
+    /**
+     * Value of the authorization header to be sent with the request.
+     */
     /*package*/ final String encodedAuthorization;
-    /*package*/ final String password;
-    /*package*/ final String apiToken;
 
     private final Map<String,GHUser> users = new HashMap<String, GHUser>();
     private final Map<String,GHOrganization> orgs = new HashMap<String, GHOrganization>();
-	/*package*/ String oauthAccessToken;
 
-    private GitHub(String login, String apiToken, String password) {
+    private final String apiUrl;
+
+    private HttpConnector connector = HttpConnector.DEFAULT;
+
+    /**
+     * Connects to GitHub.com
+     */
+    private GitHub(String login, String oauthAccessToken, String password) throws IOException {
+      this (GITHUB_URL, login, oauthAccessToken, password);
+    }
+
+    /**
+     * Creates a client API root object.
+     *
+     * <p>
+     * Several different combinations of the login/oauthAccessToken/password parameters are allowed
+     * to represent different ways of authentication.
+     *
+     * <dl>
+     *     <dt>Loging anonymously
+     *     <dd>Leave all three parameters null and you will be making HTTP requests without any authentication.
+     *
+     *     <dt>Log in with password
+     *     <dd>Specify the login and password, then leave oauthAccessToken null.
+     *         This will use the HTTP BASIC auth with the GitHub API.
+     *
+     *     <dt>Log in with OAuth token
+     *     <dd>Specify oauthAccessToken, and optionally specify the login. Leave password null.
+     *         This will send OAuth token to the GitHub API. If the login parameter is null,
+     *         The constructor makes an API call to figure out the user name that owns the token.
+     * </dl>
+     *
+     * @param apiUrl
+     *      The URL of GitHub (or GitHub enterprise) API endpoint, such as "https://api.github.com" or
+     *      "http://ghe.acme.com/api/v3". Note that GitHub Enterprise has <tt>/api/v3</tt> in the URL.
+     *      For historical reasons, this parameter still accepts the bare domain name, but that's considered deprecated.
+     *      Password is also considered deprecated as it is no longer required for api usage.
+     * @param login
+     *      The use ID on GitHub that you are logging in as. Can be omitted if the OAuth token is
+     *      provided or if logging in anonymously. Specifying this would save one API call.
+     * @param oauthAccessToken
+     *      Secret OAuth token.
+     * @param password
+     *      User's password. Always used in conjunction with the {@code login} parameter
+     */
+    private GitHub(String apiUrl, String login, String oauthAccessToken, String password) throws IOException {
+        if (apiUrl.endsWith("/")) apiUrl = apiUrl.substring(0, apiUrl.length()-1); // normalize
+        this.apiUrl = apiUrl;
+
+        if (oauthAccessToken!=null) {
+            encodedAuthorization = "token "+oauthAccessToken;
+        } else {
+            if (password!=null) {
+                String authorization = (login + ':' + password);
+                encodedAuthorization = "Basic "+new String(Base64.encodeBase64(authorization.getBytes()));
+            } else {// anonymous access
+                encodedAuthorization = null;
+            }
+        }
+
+        if (login==null && encodedAuthorization!=null)
+            login = getMyself().getLogin();
         this.login = login;
-        this.apiToken = apiToken;
-        this.password = password;
-
-        BASE64Encoder enc = new sun.misc.BASE64Encoder();
-        if (apiToken!=null || password!=null) {
-            String userpassword = password==null ? (login + "/token" + ":" + apiToken) : (login + ':'+password);
-            encodedAuthorization = enc.encode(userpassword.getBytes());
-        } else
-            encodedAuthorization = null;
     }
 
-    private GitHub (String oauthAccessToken) throws IOException {
-    	
-		this.password = null;
-		this.encodedAuthorization = null;
-		
-		this.oauthAccessToken = oauthAccessToken;
-        this.apiToken = oauthAccessToken;
-		
-		this.login = getMyself().getLogin();
-    }
-    
     /**
      * Obtains the credential from "~/.github"
      */
@@ -103,136 +144,127 @@ public class GitHub {
         } finally {
             IOUtils.closeQuietly(in);
         }
-        return new GitHub(props.getProperty("login"),props.getProperty("token"),props.getProperty("password"));
+        return new GitHub(GITHUB_URL,props.getProperty("login"), props.getProperty("oauth"),props.getProperty("password"));
     }
 
-    public static GitHub connect(String login, String apiToken) throws IOException {
-        return new GitHub(login,apiToken,null);
+    /**
+     * Version that connects to GitHub Enterprise.
+     *
+     * @param apiUrl
+     *      The URL of GitHub (or GitHub enterprise) API endpoint, such as "https://api.github.com" or
+     *      "http://ghe.acme.com/api/v3". Note that GitHub Enterprise has <tt>/api/v3</tt> in the URL.
+     *      For historical reasons, this parameter still accepts the bare domain name, but that's considered deprecated.
+     */
+    public static GitHub connectToEnterprise(String apiUrl, String oauthAccessToken) throws IOException {
+        return connectUsingOAuth(apiUrl, oauthAccessToken);
     }
 
-    public static GitHub connect(String login, String apiToken, String password) throws IOException {
-        return new GitHub(login,apiToken,password);
+    public static GitHub connectToEnterprise(String apiUrl, String login, String password) throws IOException {
+        return new GitHub(apiUrl, login, null, password);
     }
 
-    public static GitHub connectUsingOAuth (String accessToken) throws IOException {
-    	return new GitHub(accessToken);
+    public static GitHub connect(String login, String oauthAccessToken) throws IOException {
+        return new GitHub(login,oauthAccessToken,null);
+    }
+
+    /**
+     * @deprecated
+     *      Either OAuth token or password is sufficient, so there's no point in passing both.
+     *      Use {@link #connectUsingPassword(String, String)} or {@link #connectUsingOAuth(String)}.
+     */
+    public static GitHub connect(String login, String oauthAccessToken, String password) throws IOException {
+        return new GitHub(login,oauthAccessToken,password);
+    }
+
+    public static GitHub connectUsingPassword(String login, String password) throws IOException {
+        return new GitHub(login,null,password);
+    }
+
+    public static GitHub connectUsingOAuth(String oauthAccessToken) throws IOException {
+    	return new GitHub(null, oauthAccessToken, null);
+    }
+
+    public static GitHub connectUsingOAuth(String githubServer, String oauthAccessToken) throws IOException {
+    	return new GitHub(githubServer,null, oauthAccessToken,null);
     }
     /**
      * Connects to GitHub anonymously.
      *
      * All operations that requires authentication will fail.
      */
-    public static GitHub connectAnonymously() {
+    public static GitHub connectAnonymously() throws IOException {
         return new GitHub(null,null,null);
     }
 
-    /*package*/ void requireCredential() {
-        if ((login==null || encodedAuthorization==null) && oauthAccessToken == null)
-            throw new IllegalStateException("This operation requires a credential but none is given to the GitHub constructor");
+    /**
+     * Is this an anonymous connection
+     * @return {@code true} if operations that require authentication will fail.
+     */
+    public boolean isAnonymous() {
+        return login==null && encodedAuthorization==null;
     }
 
-    /*package*/ URL getApiURL(ApiVersion v, String tailApiUrl) throws IOException {
-    	if (oauthAccessToken != null) {
-    		// append the access token
-    		tailApiUrl = tailApiUrl +  (tailApiUrl.indexOf('?')>=0 ?'&':'?') + "access_token=" + oauthAccessToken;
-    	}
-    	
-        return new URL(v.url+tailApiUrl);
-    }
-
-    /*package*/ <T> T retrieve(String tailApiUrl, Class<T> type) throws IOException {
-        return _retrieve(tailApiUrl, type, "GET", false, V2);
-    }
-
-    /*package*/ <T> T retrieve3(String tailApiUrl, Class<T> type) throws IOException {
-        return _retrieve(tailApiUrl, type, "GET", false, V3);
-    }
-
-    /*package*/ <T> T retrieveWithAuth(String tailApiUrl, Class<T> type) throws IOException {
-        return retrieveWithAuth(tailApiUrl,type,"GET");
-    }
-
-    /*package*/ <T> T retrieveWithAuth3(String tailApiUrl, Class<T> type) throws IOException {
-        return _retrieve(tailApiUrl, type, "GET", true, V3);
-    }
-
-    /*package*/ <T> T retrieveWithAuth(String tailApiUrl, Class<T> type, String method) throws IOException {
-        return _retrieve(tailApiUrl, type, method, true, V2);
-    }
-
-    /*package*/ <T> T retrieveWithAuth3(String tailApiUrl, Class<T> type, String method) throws IOException {
-        return _retrieve(tailApiUrl, type, method, true, V3);
-    }
-
-    private <T> T _retrieve(String tailApiUrl, Class<T> type, String method, boolean withAuth, ApiVersion v) throws IOException {
-        while (true) {// loop while API rate limit is hit
-        	
-            HttpURLConnection uc = (HttpURLConnection) getApiURL(v,tailApiUrl).openConnection();
-
-            if (withAuth && this.oauthAccessToken == null)
-                uc.setRequestProperty("Authorization", "Basic " + encodedAuthorization);
-            
-            uc.setRequestMethod(method);
-            if (method.equals("PUT")) {
-                uc.setDoOutput(true);
-                uc.setRequestProperty("Content-Length","0");
-                uc.getOutputStream().close();
-            }
-
-            try {
-                InputStreamReader r = new InputStreamReader(uc.getInputStream(), "UTF-8");
-                if (type==null) {
-                    String data = IOUtils.toString(r);
-                    return null;
-                }
-                return MAPPER.readValue(r,type);
-            } catch (IOException e) {
-                handleApiError(e,uc);
-            }
-        }
+    public HttpConnector getConnector() {
+        return connector;
     }
 
     /**
-     * If the error is because of the API limit, wait 10 sec and return normally.
-     * Otherwise throw an exception reporting an error.
+     * Sets the custom connector used to make requests to GitHub.
      */
-    /*package*/ void handleApiError(IOException e, HttpURLConnection uc) throws IOException {
-        if ("0".equals(uc.getHeaderField("X-RateLimit-Remaining"))) {
-            // API limit reached. wait 10 secs and return normally
-            try {
-                Thread.sleep(10000);
-                return;
-            } catch (InterruptedException _) {
-                throw (InterruptedIOException)new InterruptedIOException().initCause(e);
-            }
-        }
-        
-        if (e instanceof FileNotFoundException)
-            throw e;    // pass through 404 Not Found to allow the caller to handle it intelligently
+    public void setConnector(HttpConnector connector) {
+        this.connector = connector;
+    }
 
-        InputStream es = uc.getErrorStream();
-        if (es!=null)
-            throw (IOException)new IOException(IOUtils.toString(es,"UTF-8")).initCause(e);
-        else
-            throw e;
+    /*package*/ void requireCredential() {
+        if (isAnonymous())
+            throw new IllegalStateException("This operation requires a credential but none is given to the GitHub constructor");
+    }
+
+    /*package*/ URL getApiURL(String tailApiUrl) throws IOException {
+        if (tailApiUrl.startsWith("/")) {
+            if ("github.com".equals(apiUrl)) {// backward compatibility
+                return new URL(GITHUB_URL + tailApiUrl);
+            } else {
+                return new URL(apiUrl + tailApiUrl);
+            }
+        } else {
+            return new URL(tailApiUrl);
+        }
+    }
+
+    /*package*/ Requester retrieve() {
+        return new Requester(this).method("GET");
+    }
+
+    /**
+     * Gets the current rate limit.
+     */
+    public GHRateLimit getRateLimit() throws IOException {
+        try {
+            return retrieve().to("/rate_limit", JsonRateLimit.class).rate;
+        } catch (FileNotFoundException e) {
+            // GitHub Enterprise doesn't have the rate limit, so in that case
+            // return some big number that's not too big.
+            // see issue #78
+            GHRateLimit r = new GHRateLimit();
+            r.limit = r.remaining = 1000000;
+            return r;
+        }
     }
 
     /**
 	 * Gets the {@link GHUser} that represents yourself.
 	 */
-	public GHUser getMyself() throws IOException {
+    @WithBridgeMethods(GHUser.class)
+	public GHMyself getMyself() throws IOException {
 		requireCredential();
 
-		if (oauthAccessToken != null) {
-            GHUser u = retrieveWithAuth("/user/show", JsonUser.class).user;
-			
-			u.root = this;
-			users.put(u.getLogin(), u);
-			
-			return u;
-		} else {
-			return getUser(login);
-		}
+        GHMyself u = retrieve().to("/user", GHMyself.class);
+
+        u.root = this;
+        users.put(u.getLogin(), u);
+
+        return u;
 	}
 
 	/**
@@ -241,17 +273,9 @@ public class GitHub {
 	public GHUser getUser(String login) throws IOException {
 		GHUser u = users.get(login);
 		if (u == null) {
-
-			if (oauthAccessToken != null) {
-				u = retrieve("/user/show/" + login, JsonUser.class).user;
-				u.root = this;
-				users.put(u.getLogin(), u);
-			} else {
-				u = retrieve("/user/show/" + login, JsonUser.class).user;
-				u.root = this;
-				users.put(login, u);
-			}
-
+            u = retrieve().to("/users/" + login, GHUser.class);
+            u.root = this;
+            users.put(u.getLogin(), u);
 		}
 		return u;
 	}
@@ -272,54 +296,117 @@ public class GitHub {
     public GHOrganization getOrganization(String name) throws IOException {
         GHOrganization o = orgs.get(name);
         if (o==null) {
-            o = retrieve("/organizations/"+name,JsonOrganization.class).organization;
-            o.root = this;
+            o = retrieve().to("/orgs/" + name, GHOrganization.class).wrapUp(this);
             orgs.put(name,o);
         }
         return o;
     }
 
-    public Map<String, GHOrganization> getMyOrganizations() throws IOException {
-    	 return retrieveWithAuth("/organizations",JsonOrganizations.class).wrap(this);
-        
+    /**
+     * Gets the repository object from 'user/reponame' string that GitHub calls as "repository name"
+     *
+     * @see GHRepository#getName()
+     */
+    public GHRepository getRepository(String name) throws IOException {
+        String[] tokens = name.split("/");
+        return retrieve().to("/repos/" + tokens[0] + '/' + tokens[1], GHRepository.class).wrap(this);
     }
-    
+
+    /**
+     * This method returns a shallowly populated organizations.
+     *
+     * To retrieve full organization details, you need to call {@link #getOrganization(String)}
+     * TODO: make this automatic.
+     */
+    public Map<String, GHOrganization> getMyOrganizations() throws IOException {
+        GHOrganization[] orgs = retrieve().to("/user/orgs", GHOrganization[].class);
+        Map<String, GHOrganization> r = new HashMap<String, GHOrganization>();
+        for (GHOrganization o : orgs) {
+            // don't put 'o' into orgs because they are shallow
+            r.put(o.getLogin(),o.wrapUp(this));
+        }
+        return r;
+    }
+
+    /**
+     * Public events visible to you. Equivalent of what's displayed on https://github.com/
+     */
+    public List<GHEventInfo> getEvents() throws IOException {
+        // TODO: pagination
+        GHEventInfo[] events = retrieve().to("/events", GHEventInfo[].class);
+        for (GHEventInfo e : events)
+            e.wrapUp(this);
+        return Arrays.asList(events);
+    }
+
+    /**
+     * Gets a sigle gist by ID.
+     */
+    public GHGist getGist(String id) throws IOException {
+        return retrieve().to("/gists/"+id,GHGist.class).wrapUp(this);
+    }
+
+    public GHGistBuilder createGist() {
+        return new GHGistBuilder(this);
+    }
+
+    /**
+     * Parses the GitHub event object.
+     *
+     * This is primarily intended for receiving a POST HTTP call from a hook.
+     * Unfortunately, hook script payloads aren't self-descriptive, so you need
+     * to know the type of the payload you are expecting.
+     */
+    public <T extends GHEventPayload> T parseEventPayload(Reader r, Class<T> type) throws IOException {
+        T t = MAPPER.readValue(r, type);
+        t.wrapUp(this);
+        return t;
+    }
+
     /**
      * Creates a new repository.
      *
+     * To create a repository in an organization, see
+     * {@link GHOrganization#createRepository(String, String, String, GHTeam, boolean)}
+     *
      * @return
      *      Newly created repository.
      */
     public GHRepository createRepository(String name, String description, String homepage, boolean isPublic) throws IOException {
-        return new Poster(this,V3).withCredential()
+        Requester requester = new Requester(this)
                 .with("name", name).with("description", description).with("homepage", homepage)
-                .with("public", isPublic ? 1 : 0).to("/user/repos", GHRepository.class,"POST").wrap(this);
+                .with("public", isPublic ? 1 : 0);
+        return requester.method("POST").to("/user/repos", GHRepository.class).wrap(this);
     }
 
+    /**
+     * Creates a new authorization.
+     *
+     * The token created can be then used for {@link GitHub#connectUsingOAuth(String)} in the future.
+     *
+     * @see <a href="http://developer.github.com/v3/oauth/#create-a-new-authorization">Documentation</a>
+     */
+	public GHAuthorization createToken(Collection<String> scope, String note, String noteUrl) throws IOException{
+		Requester requester = new Requester(this)
+				.with("scopes", scope)
+				.with("note", note)
+				.with("note_url", noteUrl);
+
+		return requester.method("POST").to("/authorizations", GHAuthorization.class).wrap(this);
+	}
+
     /**
      * Ensures that the credential is valid.
      */
     public boolean isCredentialValid() throws IOException {
         try {
-            retrieveWithAuth("/user/show",JsonUser.class);
+            retrieve().to("/user", GHUser.class);
             return true;
         } catch (IOException e) {
             return false;
         }
     }
 
-    WebClient createWebClient() throws IOException {
-        WebClient wc = new WebClient();
-        wc.setJavaScriptEnabled(false);
-        wc.setCssEnabled(false);
-        HtmlPage pg = (HtmlPage)wc.getPage("https://github.com/login");
-        HtmlForm f = pg.getForms().get(0);
-        f.getInputByName("login").setValueAttribute(login);
-        f.getInputByName("password").setValueAttribute(password);
-        f.submit();
-        return wc;
-    }
-
     /*package*/ static URL parseURL(String s) {
         try {
             return s==null ? null : new URL(s);
@@ -329,9 +416,12 @@ public class GitHub {
     }
 
     /*package*/ static Date parseDate(String timestamp) {
+        if (timestamp==null)    return null;
         for (String f : TIME_FORMATS) {
             try {
-                return new SimpleDateFormat(f).parse(timestamp);
+                SimpleDateFormat df = new SimpleDateFormat(f);
+                df.setTimeZone(TimeZone.getTimeZone("GMT"));
+                return df.parse(timestamp);
             } catch (ParseException e) {
                 // try next
             }
@@ -339,12 +429,18 @@ public class GitHub {
         throw new IllegalStateException("Unable to parse the timestamp: "+timestamp);
     }
 
+    /*package*/ static String printDate(Date dt) {
+        return new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'").format(dt);
+    }
+
     /*package*/ static final ObjectMapper MAPPER = new ObjectMapper();
 
     private static final String[] TIME_FORMATS = {"yyyy/MM/dd HH:mm:ss ZZZZ","yyyy-MM-dd'T'HH:mm:ss'Z'"};
 
     static {
         MAPPER.setVisibilityChecker(new Std(NONE, NONE, NONE, NONE, ANY));
-        MAPPER.getDeserializationConfig().set(Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
     }
+
+    private static final String GITHUB_URL = "https://api.github.com";
 }

src/main/java/org/kohsuke/github/GitUser.java

@@ -0,0 +1,38 @@
+package org.kohsuke.github;
+
+import java.util.Date;
+
+/**
+ * Represents a user in Git who authors/commits a commit.
+ *
+ * In contrast, {@link GHUser} is an user of GitHub. Because Git allows a person to
+ * use multiple e-mail addresses and names when creating a commit, there's generally
+ * no meaningful mapping between {@link GHUser} and {@link GitUser}.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public class GitUser {
+    private String name, email, date;
+
+    /**
+     * Human readable name of the user, such as "Kohsuke Kawaguchi"
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * E-mail address, such as "foo@example.com"
+     */
+    public String getEmail() {
+        return email;
+    }
+
+    /**
+     * This field doesn't appear to be consistently available in all the situations where this class
+     * is used.
+     */
+    public Date getDate() {
+        return GitHub.parseDate(date);
+    }
+}

src/main/java/org/kohsuke/github/HttpConnector.java

@@ -0,0 +1,29 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ * Pluggability for customizing HTTP request behaviors or using altogether different library.
+ *
+ * <p>
+ * For example, you can implement this to st custom timeouts.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public interface HttpConnector {
+    /**
+     * Opens a connection to the given URL.
+     */
+    HttpURLConnection connect(URL url) throws IOException;
+
+    /**
+     * Default implementation that uses {@link URL#openConnection()}.
+     */
+    HttpConnector DEFAULT = new HttpConnector() {
+        public HttpURLConnection connect(URL url) throws IOException {
+            return (HttpURLConnection) url.openConnection();
+        }
+    };
+}

src/main/java/org/kohsuke/github/JsonCollaborators.java

@@ -1,33 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2010, Kohsuke Kawaguchi
- *
- * 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.
- */
-package org.kohsuke.github;
-
-import java.util.List;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonCollaborators {
-    List<String> collaborators;
-}

src/main/java/org/kohsuke/github/JsonIssue.java

@@ -1,38 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2011, Eric Maupin
- *
- * 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.
- */
-
-package org.kohsuke.github;
-
-/**
- * @author Eric Maupin
- */
-class JsonIssue {
-    GHIssue issue;
-
-    GHIssue wrap(GHRepository r) {
-        issue.owner = r;
-        issue.root = r.root;
-        return issue;
-    }
-}

src/main/java/org/kohsuke/github/JsonIssueComments.java

@@ -1,16 +0,0 @@
-package org.kohsuke.github;
-
-import java.util.List;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonIssueComments {
-    List<GHIssueComment> comments;
-
-    List<GHIssueComment> wrap(GHIssue owner) {
-        for (GHIssueComment c : comments)
-            c.owner = owner;
-        return comments;
-    }
-}

src/main/java/org/kohsuke/github/JsonIssues.java

@@ -1,38 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2011, Eric Maupin
- *
- * 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.
- */
-package org.kohsuke.github;
-
-import java.util.List;
-
-class JsonIssues {
-    List<GHIssue> issues;
-
-    public List<GHIssue> wrap(GHRepository owner) {
-        for (GHIssue issue : issues) {
-            issue.owner = owner;
-            issue.root = owner.root;
-        }
-        return issues;
-    }
-}

src/main/java/org/kohsuke/github/JsonOrganizations.java

@@ -1,44 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2010, Kohsuke Kawaguchi
- *
- * 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.
- */
-package org.kohsuke.github;
-
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-
-/**
- * 
- */
-class JsonOrganizations {
-    public List<GHOrganization> organizations;
-
-    public Map<String,GHOrganization> wrap(GitHub root) {
-        Map<String,GHOrganization> map = new TreeMap<String, GHOrganization>();
-        for (GHOrganization o : organizations) {
-            o.root = root;
-            map.put(o.getLogin(),o);
-        }
-        return map;
-    }
-}

src/main/java/org/kohsuke/github/JsonPullRequest.java

@@ -1,37 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2010, Kohsuke Kawaguchi
- *
- * 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.
- */
-package org.kohsuke.github;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonPullRequest {
-    public GHPullRequest pull;
-
-    public GHPullRequest wrap(GHRepository owner) {
-        pull.owner = owner;
-        pull.root = owner.root;
-        return pull;
-    }
-}

src/main/java/org/kohsuke/github/JsonRateLimit.java

@@ -3,6 +3,6 @@ package org.kohsuke.github;
 /**
  * @author Kohsuke Kawaguchi
  */
-class JsonOrganization {
-    public GHOrganization organization;
+class JsonRateLimit {
+    GHRateLimit rate;
 }

src/main/java/org/kohsuke/github/JsonRepositories.java

@@ -1,44 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2010, Kohsuke Kawaguchi
- *
- * 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.
- */
-package org.kohsuke.github;
-
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonRepositories {
-    public List<GHRepository> repositories;
-
-    public Map<String,GHRepository> wrap(GitHub root) {
-        Map<String,GHRepository> map = new TreeMap<String, GHRepository>();
-        for (GHRepository r : repositories) {
-            r.root = root;
-            map.put(r.getName(),r);
-        }
-        return map;
-    }
-}

src/main/java/org/kohsuke/github/JsonTeam.java

@@ -1,13 +0,0 @@
-package org.kohsuke.github;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonTeam {
-    public GHTeam team;
-
-    GHTeam wrap(GHOrganization org) {
-        team.org = org;
-        return team;
-    }
-}

src/main/java/org/kohsuke/github/JsonTeams.java

@@ -1,32 +0,0 @@
-package org.kohsuke.github;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonTeams {
-    public List<GHTeam> teams;
-
-    Map<String, GHTeam> toMap(GHOrganization org) {
-        Map<String, GHTeam> r = new TreeMap<String, GHTeam>();
-        for (GHTeam t : teams) {
-            t.org = org;
-            r.put(t.getName(),t);
-        }
-        return r;
-    }
-
-    Set<GHTeam> toSet(GHOrganization org) {
-        Set<GHTeam> r = new HashSet<GHTeam>();
-        for (GHTeam t : teams) {
-            t.org = org;
-            r.add(t);
-        }
-        return r;
-    }
-}

src/main/java/org/kohsuke/github/JsonUser.java

@@ -1,31 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2010, Kohsuke Kawaguchi
- *
- * 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.
- */
-package org.kohsuke.github;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonUser {
-    public GHUser user;
-}

src/main/java/org/kohsuke/github/JsonUsers.java

@@ -1,43 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2010, Kohsuke Kawaguchi
- *
- * 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.
- */
-package org.kohsuke.github;
-
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonUsers {
-    public List<String> users;
-
-    public GHPersonSet<GHUser> toSet(GitHub root) throws IOException {
-        GHPersonSet<GHUser> r = new GHPersonSet<GHUser>();
-        for (String u : users)
-            r.add(root.getUser(u));
-        return r;
-    }
-}

src/main/java/org/kohsuke/github/JsonUsersWithDetails.java

@@ -1,20 +0,0 @@
-package org.kohsuke.github;
-
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-class JsonUsersWithDetails {
-    public List<GHUser> users;
-
-    public Set<GHUser> toSet(GitHub root) throws IOException {
-        Set<GHUser> r = new HashSet<GHUser>();
-        for (GHUser u : users)
-            r.add(root.getUser(u));
-        return r;
-    }
-}

src/main/java/org/kohsuke/github/PagedIterable.java

@@ -0,0 +1,24 @@
+package org.kohsuke.github;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * {@link Iterable} that returns {@link PagedIterator}
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public abstract class PagedIterable<T> implements Iterable<T> {
+    public abstract PagedIterator<T> iterator();
+
+    /**
+     * Eagerly walk {@link Iterable} and return the result in a list.
+     */
+    public List<T> asList() {
+        List<T> r = new ArrayList<T>();
+        for(PagedIterator<T> i = iterator(); i.hasNext();) {
+            r.addAll(i.nextPage());
+        }
+        return r;
+    }
+}

src/main/java/org/kohsuke/github/PagedIterator.java

@@ -0,0 +1,72 @@
+package org.kohsuke.github;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/**
+ * Iterator over a pagenated data source.
+ *
+ * Aside from the normal iterator operation, this method exposes {@link #nextPage()}
+ * that allows the caller to retrieve items per page.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public abstract class PagedIterator<T> implements Iterator<T> {
+    private final Iterator<T[]> base;
+
+    /**
+     * Current batch that we retrieved but haven't returned to the caller.
+     */
+    private T[] current;
+    private int pos;
+
+    /*package*/ PagedIterator(Iterator<T[]> base) {
+        this.base = base;
+    }
+
+    protected abstract void wrapUp(T[] page);
+
+    public boolean hasNext() {
+        fetch();
+        return current!=null;
+    }
+
+    public T next() {
+        fetch();
+        if (current==null)  throw new NoSuchElementException();
+        return current[pos++];
+    }
+
+    private void fetch() {
+        while (current==null || current.length<=pos) {
+            if (!base.hasNext()) {// no more to retrieve
+                current = null;
+                pos = 0;
+                return;
+            }
+
+            current = base.next();
+            wrapUp(current);
+            pos = 0;
+        }
+        // invariant at the end: there's some data to retrieve
+    }
+
+    public void remove() {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Gets the next page worth of data.
+     */
+    public List<T> nextPage() {
+        fetch();
+        List<T> r = Arrays.asList(current);
+        r = r.subList(pos,r.size());
+        current = null;
+        pos = 0;
+        return r;
+    }
+}

src/main/java/org/kohsuke/github/Poster.java

@@ -1,172 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2010, Kohsuke Kawaguchi
- *
- * 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.
- */
-package org.kohsuke.github;
-
-import org.apache.commons.io.IOUtils;
-import org.codehaus.jackson.JsonNode;
-import org.codehaus.jackson.impl.WriterBasedGenerator;
-import org.codehaus.jackson.node.ObjectNode;
-
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.Reader;
-import java.io.UnsupportedEncodingException;
-import java.net.HttpURLConnection;
-import java.net.URLEncoder;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.kohsuke.github.GitHub.*;
-
-/**
- * Handles HTTP POST.
- * @author Kohsuke Kawaguchi
- */
-class Poster {
-    private final GitHub root;
-    private final List<Entry> args = new ArrayList<Entry>();
-    private boolean authenticate;
-
-    private final ApiVersion v;
-
-    private static class Entry {
-        String key;
-        Object value;
-
-        private Entry(String key, Object value) {
-            this.key = key;
-            this.value = value;
-        }
-
-        public String toFormArg() throws UnsupportedEncodingException {
-            return URLEncoder.encode(key,"UTF-8")+'='+URLEncoder.encode(value.toString(),"UTF-8");
-        }
-    }
-
-    Poster(GitHub root, ApiVersion v) {
-        this.root = root;
-        this.v = v;
-    }
-
-    Poster(GitHub root) {
-        this(root,ApiVersion.V2);
-    }
-
-    public Poster withCredential() {
-        root.requireCredential();
-        authenticate = true;
-        return this;
-    }
-
-    public Poster with(String key, int value) {
-        return _with(key, value);
-    }
-
-    public Poster with(String key, boolean value) {
-        return _with(key, value);
-    }
-
-    public Poster with(String key, String value) {
-        return _with(key, value);
-    }
-
-    public Poster _with(String key, Object value) {
-        if (value!=null) {
-            args.add(new Entry(key,value));
-        }
-        return this;
-    }
-
-    public void to(String tailApiUrl) throws IOException {
-        to(tailApiUrl,null);
-    }
-
-    /**
-     * POSTs the form to the specified URL.
-     *
-     * @throws IOException
-     *      if the server returns 4xx/5xx responses.
-     * @return
-     *      {@link Reader} that reads the response.
-     */
-    public <T> T to(String tailApiUrl, Class<T> type) throws IOException {
-        return to(tailApiUrl,type,"POST");
-    }
-
-    public <T> T to(String tailApiUrl, Class<T> type, String method) throws IOException {
-        while (true) {// loop while API rate limit is hit
-            HttpURLConnection uc = (HttpURLConnection) root.getApiURL(v,tailApiUrl).openConnection();
-
-            uc.setDoOutput(true);
-            uc.setRequestProperty("Content-type","application/x-www-form-urlencoded");
-            if (authenticate) {
-                if (v==ApiVersion.V3) {
-                    if (root.oauthAccessToken!=null) {
-                        uc.setRequestProperty("Authorization", "token " + root.oauthAccessToken);
-                    } else {
-                        if (root.password==null)
-                            throw new IllegalArgumentException("V3 API doesn't support API token");
-                        uc.setRequestProperty("Authorization", "Basic " + root.encodedAuthorization);
-                    }
-                } else {
-                    uc.setRequestProperty("Authorization", "Basic " + root.encodedAuthorization);
-                }
-            }
-            uc.setRequestMethod(method);
-
-
-            if (v==ApiVersion.V2) {
-                StringBuilder body = new StringBuilder();
-                for (Entry e : args) {
-                    if (body.length()>0)    body.append('&');
-                    body.append(e.toFormArg());
-                }
-
-                OutputStreamWriter o = new OutputStreamWriter(uc.getOutputStream(), "UTF-8");
-                o.write(body.toString());
-                o.close();
-            } else {
-                Map json = new HashMap();
-                for (Entry e : args) {
-                    json.put(e.key, e.value);
-                }
-                MAPPER.writeValue(uc.getOutputStream(),json);
-            }
-
-            try {
-                InputStreamReader r = new InputStreamReader(uc.getInputStream(), "UTF-8");
-                String data = IOUtils.toString(r);
-                if (type==null) {
-                    return null;
-                }
-                return MAPPER.readValue(data,type);
-            } catch (IOException e) {
-                root.handleApiError(e,uc);
-            }
-        }
-    }
-}

src/main/java/org/kohsuke/github/Requester.java

@@ -0,0 +1,417 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2010, Kohsuke Kawaguchi
+ *
+ * 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.
+ */
+package org.kohsuke.github;
+
+import static org.kohsuke.github.GitHub.MAPPER;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.InterruptedIOException;
+import java.io.Reader;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Field;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.zip.GZIPInputStream;
+
+import org.apache.commons.io.IOUtils;
+
+/**
+ * A builder pattern for making HTTP call and parsing its output.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+class Requester {
+    private final GitHub root;
+    private final List<Entry> args = new ArrayList<Entry>();
+
+    /**
+     * Request method.
+     */
+    private String method = "POST";
+    private String contentType = "application/x-www-form-urlencoded";
+    private InputStream body;
+
+    private static class Entry {
+        String key;
+        Object value;
+
+        private Entry(String key, Object value) {
+            this.key = key;
+            this.value = value;
+        }
+    }
+
+    Requester(GitHub root) {
+        this.root = root;
+    }
+
+    /**
+     * Makes a request with authentication credential.
+     */
+    @Deprecated
+    public Requester withCredential() {
+        // keeping it inline with retrieveWithAuth not to enforce the check
+        // root.requireCredential();
+        return this;
+    }
+
+    public Requester with(String key, int value) {
+        return _with(key, value);
+    }
+
+    public Requester with(String key, Integer value) {
+        if (value!=null)
+            _with(key, value.intValue());
+        return this;
+    }
+
+    public Requester with(String key, boolean value) {
+        return _with(key, value);
+    }
+
+    public Requester with(String key, String value) {
+        return _with(key, value);
+    }
+
+    public Requester with(String key, Collection<String> value) {
+        return _with(key, value);
+    }
+
+    public Requester with(String key, Map<String, String> value) {
+        return _with(key, value);
+    }
+
+    public Requester with(InputStream body) {
+        this.body = body;
+        return this;
+    }
+
+    public Requester _with(String key, Object value) {
+        if (value!=null) {
+            args.add(new Entry(key,value));
+        }
+        return this;
+    }
+
+    public Requester method(String method) {
+        this.method = method;
+        return this;
+    }
+
+    public Requester contentType(String contentType) {
+        this.contentType = contentType;
+        return this;
+    }
+
+    public void to(String tailApiUrl) throws IOException {
+        to(tailApiUrl,null);
+    }
+
+    /**
+     * Sends a request to the specified URL, and parses the response into the given type via databinding.
+     *
+     * @throws IOException
+     *      if the server returns 4xx/5xx responses.
+     * @return
+     *      {@link Reader} that reads the response.
+     */
+    public <T> T to(String tailApiUrl, Class<T> type) throws IOException {
+        return _to(tailApiUrl, type, null);
+    }
+
+    /**
+     * Like {@link #to(String, Class)} but updates an existing object instead of creating a new instance.
+     */
+    public <T> T to(String tailApiUrl, T existingInstance) throws IOException {
+        return _to(tailApiUrl, null, existingInstance);
+    }
+
+    /**
+     * Short for {@code method(method).to(tailApiUrl,type)}
+     */
+    @Deprecated
+    public <T> T to(String tailApiUrl, Class<T> type, String method) throws IOException {
+        return method(method).to(tailApiUrl,type);
+    }
+
+    private <T> T _to(String tailApiUrl, Class<T> type, T instance) throws IOException {
+        while (true) {// loop while API rate limit is hit
+            HttpURLConnection uc = setupConnection(root.getApiURL(tailApiUrl));
+
+            buildRequest(uc);
+
+            try {
+                return parse(uc,type,instance);
+            } catch (IOException e) {
+                handleApiError(e,uc);
+            }
+        }
+    }
+
+    /**
+     * Makes a request and just obtains the HTTP status code.
+     */
+    public int asHttpStatusCode(String tailApiUrl) throws IOException {
+        while (true) {// loop while API rate limit is hit
+            HttpURLConnection uc = setupConnection(root.getApiURL(tailApiUrl));
+
+            buildRequest(uc);
+
+            try {
+                return uc.getResponseCode();
+            } catch (IOException e) {
+                handleApiError(e,uc);
+            }
+        }
+    }
+
+    private void buildRequest(HttpURLConnection uc) throws IOException {
+        if (!method.equals("GET")) {
+            uc.setDoOutput(true);
+            uc.setRequestProperty("Content-type", contentType);
+
+            if (body == null) {
+                Map json = new HashMap();
+                for (Entry e : args) {
+                    json.put(e.key, e.value);
+                }
+                MAPPER.writeValue(uc.getOutputStream(), json);
+            } else {
+                try {
+                    byte[] bytes = new byte[32768];
+                    int read = 0;
+                    while ((read = body.read(bytes)) != -1) {
+                        uc.getOutputStream().write(bytes, 0, read);
+                    }
+                } finally {
+                    body.close();
+                }
+            }
+        }
+    }
+
+    /**
+     * Loads pagenated resources.
+     *
+     * Every iterator call reports a new batch.
+     */
+    /*package*/ <T> Iterator<T> asIterator(String _tailApiUrl, final Class<T> type) {
+        method("GET");
+
+        if (!args.isEmpty()) {
+            boolean first=true;
+            try {
+                for (Entry a : args) {
+                    _tailApiUrl += first ? '?' : '&';
+                    first = false;
+                    _tailApiUrl += URLEncoder.encode(a.key,"UTF-8")+'='+URLEncoder.encode(a.value.toString(),"UTF-8");
+                }
+            } catch (UnsupportedEncodingException e) {
+                throw new AssertionError(e);    // UTF-8 is mandatory
+            }
+        }
+
+        final String tailApiUrl = _tailApiUrl;
+
+        return new Iterator<T>() {
+            /**
+             * The next batch to be returned from {@link #next()}.
+             */
+            T next;
+            /**
+             * URL of the next resource to be retrieved, or null if no more data is available.
+             */
+            URL url;
+
+            {
+                try {
+                    url = root.getApiURL(tailApiUrl);
+                } catch (IOException e) {
+                    throw new Error(e);
+                }
+            }
+
+            public boolean hasNext() {
+                fetch();
+                return next!=null;
+            }
+
+            public T next() {
+                fetch();
+                T r = next;
+                if (r==null)    throw new NoSuchElementException();
+                next = null;
+                return r;
+            }
+
+            public void remove() {
+                throw new UnsupportedOperationException();
+            }
+
+            private void fetch() {
+                if (next!=null) return; // already fetched
+                if (url==null)  return; // no more data to fetch
+
+                try {
+                    while (true) {// loop while API rate limit is hit
+                        HttpURLConnection uc = setupConnection(url);
+                        try {
+                            next = parse(uc,type,null);
+                            assert next!=null;
+                            findNextURL(uc);
+                            return;
+                        } catch (IOException e) {
+                            handleApiError(e,uc);
+                        }
+                    }
+                } catch (IOException e) {
+                    throw new Error(e);
+                }
+            }
+
+            /**
+             * Locate the next page from the pagination "Link" tag.
+             */
+            private void findNextURL(HttpURLConnection uc) throws MalformedURLException {
+                url = null; // start defensively
+                String link = uc.getHeaderField("Link");
+                if (link==null) return;
+
+                for (String token : link.split(", ")) {
+                    if (token.endsWith("rel=\"next\"")) {
+                        // found the next page. This should look something like
+                        // <https://api.github.com/repos?page=3&per_page=100>; rel="next"
+                        int idx = token.indexOf('>');
+                        url = new URL(token.substring(1,idx));
+                        return;
+                    }
+                }
+
+                // no more "next" link. we are done.
+            }
+        };
+    }
+
+
+    private HttpURLConnection setupConnection(URL url) throws IOException {
+        HttpURLConnection uc = root.getConnector().connect(url);
+
+        // if the authentication is needed but no credential is given, try it anyway (so that some calls
+        // that do work with anonymous access in the reduced form should still work.)
+        if (root.encodedAuthorization!=null)
+            uc.setRequestProperty("Authorization", root.encodedAuthorization);
+
+        try {
+            uc.setRequestMethod(method);
+        } catch (ProtocolException e) {
+            // JDK only allows one of the fixed set of verbs. Try to override that
+            try {
+                Field $method = HttpURLConnection.class.getDeclaredField("method");
+                $method.setAccessible(true);
+                $method.set(uc,method);
+            } catch (Exception x) {
+                throw (IOException)new IOException("Failed to set the custom verb").initCause(x);
+            }
+        }
+        uc.setRequestProperty("Accept-Encoding", "gzip");
+        return uc;
+    }
+
+    private <T> T parse(HttpURLConnection uc, Class<T> type, T instance) throws IOException {
+        InputStreamReader r = null;
+        try {
+            r = new InputStreamReader(wrapStream(uc, uc.getInputStream()), "UTF-8");
+            String data = IOUtils.toString(r);
+            if (type!=null)
+                return MAPPER.readValue(data,type);
+            if (instance!=null)
+                return MAPPER.readerForUpdating(instance).<T>readValue(data);
+            return null;
+        } finally {
+            IOUtils.closeQuietly(r);
+        }
+    }
+
+    /**
+     * Handles the "Content-Encoding" header.
+     */
+    private InputStream wrapStream(HttpURLConnection uc, InputStream in) throws IOException {
+        String encoding = uc.getContentEncoding();
+        if (encoding==null || in==null) return in;
+        if (encoding.equals("gzip"))    return new GZIPInputStream(in);
+
+        throw new UnsupportedOperationException("Unexpected Content-Encoding: "+encoding);
+    }
+
+    /**
+     * If the error is because of the API limit, wait 10 sec and return normally.
+     * Otherwise throw an exception reporting an error.
+     */
+    /*package*/ void handleApiError(IOException e, HttpURLConnection uc) throws IOException {
+        if ("0".equals(uc.getHeaderField("X-RateLimit-Remaining"))) {
+            // API limit reached. wait 10 secs and return normally
+            try {
+                Thread.sleep(10000);
+                return;
+            } catch (InterruptedException _) {
+                throw (InterruptedIOException)new InterruptedIOException().initCause(e);
+            }
+        }
+
+        if (e instanceof FileNotFoundException)
+            throw e;    // pass through 404 Not Found to allow the caller to handle it intelligently
+
+        InputStream es = wrapStream(uc, uc.getErrorStream());
+        try {
+            if (es!=null)
+                throw (IOException)new IOException(IOUtils.toString(es,"UTF-8")).initCause(e);
+            else
+                throw e;
+        } finally {
+            IOUtils.closeQuietly(es);
+        }
+    }
+
+    private Set<String> toSet(String s) {
+        Set<String> r = new HashSet<String>();
+        for (String t : s.split(","))
+            r.add(t.trim());
+        return r;
+    }
+}

src/main/java/org/kohsuke/github/extras/OkHttpConnector.java

@@ -0,0 +1,31 @@
+package org.kohsuke.github.extras;
+
+import com.squareup.okhttp.OkHttpClient;
+import org.kohsuke.github.HttpConnector;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ * {@link HttpConnector} for {@link OkHttpClient}.
+ *
+ * Unlike {@link #DEFAULT}, OkHttp does response caching.
+ * Making a conditional request against GitHubAPI and receiving a 304
+ * response does not count against the rate limit.
+ * See http://developer.github.com/v3/#conditional-requests
+ *
+ * @author Roberto Tyley
+ * @author Kohsuke Kawaguchi
+ */
+public class OkHttpConnector implements HttpConnector {
+    private final OkHttpClient client;
+
+    public OkHttpConnector(OkHttpClient client) {
+        this.client = client;
+    }
+
+    public HttpURLConnection connect(URL url) throws IOException {
+        return client.open(url);
+    }
+}

src/site/apt/index.apt

@@ -1,25 +0,0 @@
-What is this?
-
-  This library defines an object oriented representation of the GitHub API. The library doesn't yet cover the entirety of the GitHub API, but it's implemented with the right abstractions and libraries to make it very easy to improve the coverage.
-
-Sample Usage
-
-------------------
-GitHub github = GitHub.connect();
-GHRepository repo = github.createRepository(
-  "new-repository","this is my new repository",
-  "http://www.kohsuke.org/",true/*public*/);
-repo.addCollaborators(github.getUser("abayer"),github.getUser("rtyler"));
-repo.delete();
-------------------
-
-Credential
-
-  This library allows the caller to supply the credential as parameters, but it also defines a common convention
-  so that applications using this library will look at the consistent location. In this convention, the library
-  looks at "~/.github" property file, which should have the following two values:
-
-------------------
-login=kohsuke
-token=012345678
-------------------

src/site/markdown/index.md

@@ -0,0 +1,45 @@
+What is this?
+=====
+
+This library defines an object oriented representation of the GitHub API. By "object oriented" we mean
+there are classes that correspond to the domain model of GitHub (such as `GHUser` and `GHRepository`),
+operations that act on them as defined as methods (such as `GHUser.follow()`), and those object references
+are used in favor of using string handle (such as `GHUser.isMemberOf(GHOrganization)` instead of
+`GHUser.isMemberOf(String)`)
+
+The library supports both github.com and GitHub Enterprise.
+
+There are some corners of the GitHub API that's not yet implemented, but
+the library is implemented with the right abstractions and libraries to make it very easy to improve the coverage.
+
+Sample Usage
+-----
+
+    GitHub github = GitHub.connect();
+    GHRepository repo = github.createRepository(
+      "new-repository","this is my new repository",
+      "http://www.kohsuke.org/",true/*public*/);
+    repo.addCollaborators(github.getUser("abayer"),github.getUser("rtyler"));
+    repo.delete();
+
+Credential
+----
+
+This library allows the caller to supply the credential as parameters, but it also defines a common convention
+so that applications using this library will look at the consistent location. In this convention, the library
+looks at `~/.github` property file, which should have the following two values:
+
+    login=kohsuke
+    password=012345678
+
+Alternatively, you can have just the OAuth token in this file:
+
+    oauth=4d98173f7c075527cb64878561d1fe70
+
+OkHttp
+----
+This library comes with a pluggable connector to use different HTTP client implementations
+through `HttpConnector`. In particular, this means you can use [OkHttp](http://square.github.io/okhttp/),
+so we can make use of it's HTTP response cache.
+Making a conditional request against the GitHub API and receiving a 304 response
+[does not count against the rate limit](http://developer.github.com/v3/#conditional-requests).

src/test/java/Foo.java

@@ -0,0 +1,23 @@
+import org.kohsuke.github.GHOrganization;
+import org.kohsuke.github.GHTeam;
+import org.kohsuke.github.GitHub;
+
+import java.util.Arrays;
+import java.util.Map;
+
+/**
+ * @author Kohsuke Kawaguchi
+ */
+public class Foo {
+    public static void main(String[] args) throws Exception {
+        GHOrganization org = GitHub.connect().getOrganization("jenkinsci");
+        Map<String, GHTeam> teams = org.getTeams();
+        System.out.println(teams.size());
+
+        int sz = 0;
+        for (GHTeam t : org.listTeams()) {
+            sz++;
+        }
+        System.out.println(sz);
+    }
+}

src/test/java/org/kohsuke/AppTest.java

@@ -1,159 +0,0 @@
-package org.kohsuke;
-
-import junit.framework.TestCase;
-import org.kohsuke.github.GHHook;
-import org.kohsuke.github.GHOrganization;
-import org.kohsuke.github.GHOrganization.Permission;
-import org.kohsuke.github.GHRepository;
-import org.kohsuke.github.GHTeam;
-import org.kohsuke.github.GitHub;
-
-import java.io.IOException;
-import java.net.URL;
-import java.util.Set;
-
-/**
- * Unit test for simple App.
- */
-public class AppTest extends TestCase {
-    public void testCredentialValid() throws IOException {
-        assertTrue(GitHub.connect().isCredentialValid());
-        assertFalse(GitHub.connect("totally","bogus").isCredentialValid());
-    }
-
-    public void tryOrgFork() throws Exception {
-        GitHub gh = GitHub.connect();
-        gh.getUser("kohsuke").getRepository("rubywm").forkTo(gh.getOrganization("jenkinsci"));
-    }
-
-    public void tryGetTeamsForRepo() throws Exception {
-        GitHub gh = GitHub.connect();
-        Set<GHTeam> o = gh.getOrganization("jenkinsci").getRepository("rubywm").getTeams();
-        System.out.println(o);
-    }
-
-    public void testMembership() throws Exception {
-        GitHub gitHub = GitHub.connect();
-        Set<String> members = gitHub.getOrganization("jenkinsci").getRepository("violations-plugin").getCollaboratorNames();
-        System.out.println(members.contains("kohsuke"));
-    }
-    
-    public void testMemberOrgs() throws Exception {
-        GitHub gitHub = GitHub.connect();
-        Set<GHOrganization> o = gitHub.getUser("kohsuke").getOrganizations();
-        System.out.println(o);
-    }
-
-    public void tryHook() throws Exception {
-        GitHub gitHub = GitHub.connect();
-        GHRepository r = gitHub.getMyself().getRepository("test2");
-        GHHook hook = r.createWebHook(new URL("http://www.google.com/"));
-        System.out.println(hook);
-
-        for (GHHook h : r.getHooks())
-            h.delete();
-    }
-
-    public void testApp() throws IOException {
-        GitHub gitHub = GitHub.connect();
-
-//        GHRepository r = gitHub.connect().getOrganization("jenkinsci").createRepository("kktest4", "Kohsuke's test", "http://kohsuke.org/", "Everyone", true);
-//        r.fork();
-
-//        tryDisablingIssueTrackers(gitHub);
-
-//        tryDisablingWiki(gitHub);
-
-//        GHPullRequest i = gitHub.getOrganization("jenkinsci").getRepository("sandbox").getPullRequest(1);
-//        for (GHIssueComment c : i.getComments())
-//            System.out.println(c);
-//        System.out.println(i);
-
-//        gitHub.getMyself().getRepository("perforce-plugin").setEmailServiceHook("kk@kohsuke.org");
-
-//        tryRenaming(gitHub);
-//        tryOrgFork(gitHub);
-
-//        testOrganization(gitHub);
-//        testPostCommitHook(gitHub);
-
-//        tryTeamCreation(gitHub);
-
-//        t.add(gitHub.getMyself());
-//        System.out.println(t.getMembers());
-//        t.remove(gitHub.getMyself());
-//        System.out.println(t.getMembers());
-
-//        GHRepository r = GitHub.connect().getOrganization("HudsonLabs").createRepository("auto-test", "some description", "http://kohsuke.org/", "Plugin Developers", true);
-
-//        r.
-//        GitHub hub = GitHub.connectAnonymously();
-////        hub.createRepository("test","test repository",null,true);
-////        hub.getUser("kohsuke").getRepository("test").delete();
-//
-//        System.out.println(hub.getUser("kohsuke").getRepository("hudson").getCollaborators());
-    }
-
-    private void tryDisablingIssueTrackers(GitHub gitHub) throws IOException {
-        for (GHRepository r : gitHub.getOrganization("jenkinsci").getRepositories().values()) {
-            if (r.hasIssues()) {
-                if (r.getOpenIssueCount()==0) {
-                    System.out.println("DISABLED  "+r.getName());
-                    r.enableIssueTracker(false);
-                } else {
-                    System.out.println("UNTOUCHED "+r.getName());
-                }
-            }
-        }
-    }
-
-    private void tryDisablingWiki(GitHub gitHub) throws IOException {
-        for (GHRepository r : gitHub.getOrganization("jenkinsci").getRepositories().values()) {
-            if (r.hasWiki()) {
-                System.out.println("DISABLED  "+r.getName());
-                r.enableWiki(false);
-            }
-        }
-    }
-
-    private void tryUpdatingIssueTracker(GitHub gitHub) throws IOException {
-        GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("lib-task-reactor");
-        System.out.println(r.hasIssues());
-        System.out.println(r.getOpenIssueCount());
-        r.enableIssueTracker(false);
-    }
-
-    private void tryRenaming(GitHub gitHub) throws IOException {
-        gitHub.getUser("kohsuke").getRepository("test").renameTo("test2");
-    }
-
-    private void tryOrgFork(GitHub gitHub) throws IOException {
-        GHOrganization o = gitHub.getOrganization("HudsonLabs");
-        System.out.println(gitHub.getUser("rtyler").getRepository("memcache-ada").forkTo(o).getUrl());
-    }
-
-    private void tryTeamCreation(GitHub gitHub) throws IOException {
-        GHOrganization o = gitHub.getOrganization("HudsonLabs");
-        GHTeam t = o.createTeam("auto team", Permission.PUSH);
-        t.add(o.getRepository("auto-test"));
-    }
-
-    private void testPostCommitHook(GitHub gitHub) throws IOException {
-        GHRepository r = gitHub.getMyself().getRepository("foo");
-        Set<URL> hooks = r.getPostCommitHooks();
-        hooks.add(new URL("http://kohsuke.org/test"));
-        System.out.println(hooks);
-        hooks.remove(new URL("http://kohsuke.org/test"));
-        System.out.println(hooks);
-    }
-
-    public void testOrganization() throws IOException {
-        GitHub gitHub = GitHub.connect();
-        GHOrganization j = gitHub.getOrganization("jenkinsci");
-        GHTeam t = j.getTeams().get("Core Developers");
-
-        assertNotNull(j.getRepository("jenkins"));
-
-//        t.add(labs.getRepository("xyz"));
-    }
-}

src/test/java/org/kohsuke/HookApp.java

@@ -0,0 +1,32 @@
+package org.kohsuke;
+
+import org.kohsuke.github.GHEventPayload;
+import org.kohsuke.github.GitHub;
+import org.kohsuke.stapler.StaplerRequest;
+import org.kohsuke.stapler.jetty.JettyRunner;
+
+import java.io.IOException;
+import java.io.StringReader;
+
+/**
+ * App to test the hook script. You need some internet-facing server that can forward the request to you
+ * (typically via SSH reverse port forwarding.)
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public class HookApp {
+    public static void main(String[] args) throws Exception {
+//        GitHub.connect().getMyself().getRepository("sandbox").createWebHook(
+//                new URL("http://173.203.118.45:18080/"), EnumSet.of(GHEvent.PULL_REQUEST));
+        JettyRunner jr = new JettyRunner(new HookApp());
+        jr.addHttpListener(8080);
+        jr.start();
+    }
+
+    public void doIndex(StaplerRequest req) throws IOException {
+        String str = req.getParameter("payload");
+        System.out.println(str);
+        GHEventPayload.PullRequest o = GitHub.connect().parseEventPayload(new StringReader(str),GHEventPayload.PullRequest.class);
+        System.out.println(o);
+    }
+}

src/test/java/org/kohsuke/github/AbstractGitHubApiTestBase.java

@@ -0,0 +1,36 @@
+package org.kohsuke.github;
+
+import org.apache.commons.io.IOUtils;
+import org.junit.Assert;
+import org.junit.Before;
+import org.kohsuke.randname.RandomNameGenerator;
+
+import java.io.FileInputStream;
+import java.util.Properties;
+
+/**
+ * @author Kohsuke Kawaguchi
+ */
+public abstract class AbstractGitHubApiTestBase extends Assert {
+
+    protected GitHub gitHub;
+
+    @Before
+    public void setUp() throws Exception {
+        Properties props = new Properties();
+        java.io.File f = new java.io.File(System.getProperty("user.home"), ".github.kohsuke2");
+        if (f.exists()) {
+            FileInputStream in = new FileInputStream(f);
+            try {
+                props.load(in);
+                gitHub = GitHub.connect(props.getProperty("login"),props.getProperty("oauth"));
+            } finally {
+                IOUtils.closeQuietly(in);
+            }
+        } else {
+            gitHub = GitHub.connect();
+        }
+    }
+
+    protected static final RandomNameGenerator rnd = new RandomNameGenerator();
+}

src/test/java/org/kohsuke/github/AppTest.java

@@ -0,0 +1,573 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Assume;
+import org.junit.Test;
+import org.kohsuke.github.GHCommit.File;
+import org.kohsuke.github.GHOrganization.Permission;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+
+import java.util.Date;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest extends AbstractGitHubApiTestBase {
+    private String getTestRepositoryName() throws IOException {
+        return getUser().getLogin() + "/github-api-test";
+    }
+
+    @Test
+    public void testRepoCRUD() throws Exception {
+        String targetName = "github-api-test-rename2";
+
+        deleteRepository("github-api-test-rename");
+        deleteRepository(targetName);
+        GHRepository r = gitHub.createRepository("github-api-test-rename", "a test repository", "http://github-api.kohsuke.org/", true);
+        r.enableIssueTracker(false);
+        r.enableDownloads(false);
+        r.enableWiki(false);
+        r.renameTo(targetName);
+        getUser().getRepository(targetName).delete();
+    }
+
+    private void deleteRepository(final String name) throws IOException {
+        GHRepository repository = getUser().getRepository(name);
+        if(repository != null) {
+            repository.delete();
+        }
+    }
+
+    @Test
+    public void testCredentialValid() throws IOException {
+        assertTrue(gitHub.isCredentialValid());
+        GitHub connect = GitHub.connect("totally", "bogus");
+        assertFalse(connect.isCredentialValid());
+    }
+
+    @Test
+    public void testIssueWithNoComment() throws IOException {
+        GHRepository repository = gitHub.getRepository("kohsuke/test");
+        List<GHIssueComment> v = repository.getIssue(4).getComments();
+        System.out.println(v);
+        assertTrue(v.isEmpty());
+
+        v = repository.getIssue(3).getComments();
+        System.out.println(v);
+        assertTrue(v.size() == 3);
+    }
+
+    @Test
+    public void testCreateIssue() throws IOException {
+        GHUser u = getUser();
+        GHRepository repository = getTestRepository();
+        GHMilestone milestone = repository.createMilestone(System.currentTimeMillis() + "", "Test Milestone");
+        GHIssue o = repository.createIssue("testing")
+                .body("this is body")
+                .assignee(u)
+                .label("bug")
+                .label("question")
+                .milestone(milestone)
+                .create();
+        assertNotNull(o);
+        o.close();
+    }
+
+    @Test
+    public void testGetIssues() throws Exception {
+        List<GHIssue> closedIssues = gitHub.getUser("kohsuke").getRepository("github-api").getIssues(GHIssueState.CLOSED);
+        // prior to using PagedIterable GHRepository.getIssues(GHIssueState) would only retrieve 30 issues
+        assertTrue(closedIssues.size() > 30);
+    }
+
+
+    private GHRepository getTestRepository() throws IOException {
+        GHRepository repository;
+        try {
+            repository = gitHub.getRepository(getTestRepositoryName());
+        } catch (IOException e) {
+            repository = gitHub.createRepository("github-api-test", "A test repository for testing" +
+                    "the github-api project", "http://github-api.kohsuke.org/", true);
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException e1) {
+                throw new RuntimeException(e.getMessage(), e);
+            }
+            repository.enableIssueTracker(true);
+            repository.enableDownloads(true);
+            repository.enableWiki(true);
+        }
+        return repository;
+    }
+
+    private GHUser getUser() {
+        try {
+            return gitHub.getMyself();
+        } catch (IOException e) {
+            throw new RuntimeException(e.getMessage(), e);
+        }
+    }
+
+    @Test
+    public void testListIssues() throws IOException {
+        GHUser u = getUser();
+        GHRepository repository = getTestRepository();
+
+        GHMilestone milestone = repository.createMilestone(System.currentTimeMillis() + "", "Test Milestone");
+        milestone.close();
+        GHIssue unhomed = null;
+        GHIssue homed = null;
+        try {
+            unhomed = repository.createIssue("testing").body("this is body")
+                    .assignee(u)
+                    .label("bug")
+                    .label("question")
+                    .create();
+            assertEquals(unhomed.getNumber(), repository.getIssues(GHIssueState.OPEN, null).get(0).getNumber());
+            homed = repository.createIssue("testing").body("this is body")
+                    .assignee(u)
+                    .label("bug")
+                    .label("question")
+                    .milestone(milestone)
+                    .create();
+            assertEquals(homed.getNumber(), repository.getIssues(GHIssueState.OPEN, milestone).get(0).getNumber());
+        } finally {
+            if (unhomed != null) {
+                unhomed.close();
+            }
+            if (homed != null) {
+                homed.close();
+            }
+        }
+    }
+
+    @Test
+    public void testRateLimit() throws IOException {
+        System.out.println(gitHub.getRateLimit());
+    }
+
+    @Test
+    public void testMyOrganizations() throws IOException {
+        Map<String, GHOrganization> org = gitHub.getMyOrganizations();
+        assertFalse(org.keySet().contains(null));
+        System.out.println(org);
+    }
+
+    @Test
+    public void testFetchPullRequest() throws Exception {
+        GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("jenkins");
+        assertEquals("master",r.getMasterBranch());
+        r.getPullRequest(1);
+        r.getPullRequests(GHIssueState.OPEN);
+    }
+
+    @Test
+    public void testFetchPullRequestAsList() throws Exception {
+        GHRepository r = gitHub.getRepository("kohsuke/github-api");
+        assertEquals("master", r.getMasterBranch());
+        PagedIterable<GHPullRequest> i = r.listPullRequests(GHIssueState.CLOSED);
+        List<GHPullRequest> prs = i.asList();
+        assertNotNull(prs);
+        assertTrue(prs.size() > 0);
+    }
+
+    @Test
+    public void testRepoPermissions() throws Exception {
+        kohsuke();
+        GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("jenkins");
+        assertTrue(r.hasPullAccess());
+
+        r = gitHub.getOrganization("github").getRepository("hub");
+        assertFalse(r.hasAdminAccess());
+    }
+    
+    @Test
+    public void testGetMyself() throws Exception {
+        GHMyself me = gitHub.getMyself();
+        assertNotNull(me);
+        assertNotNull(gitHub.getUser("kohsuke2"));
+        PagedIterable<GHRepository> ghRepositories = me.listRepositories();
+        assertTrue(ghRepositories.iterator().hasNext());
+    }
+
+    @Test
+    public void testPublicKeys() throws Exception {
+        List<GHKey> keys = gitHub.getMyself().getPublicKeys();
+        assertFalse(keys.isEmpty());
+    }
+
+    @Test
+    public void testOrgFork() throws Exception {
+        kohsuke();
+        gitHub.getRepository("kohsuke/rubywm").forkTo(gitHub.getOrganization("github-api-test-org"));
+    }
+
+    @Test
+    public void testGetTeamsForRepo() throws Exception {
+        kohsuke();
+        assertEquals(1,gitHub.getOrganization("github-api-test-org").getRepository("testGetTeamsForRepo").getTeams().size());
+    }
+
+    @Test
+    public void testMembership() throws Exception {
+        Set<String> members = gitHub.getOrganization("jenkinsci").getRepository("violations-plugin").getCollaboratorNames();
+        System.out.println(members.contains("kohsuke"));
+    }
+
+    @Test
+    public void testMemberOrgs() throws Exception {
+        Set<GHOrganization> o = gitHub.getUser("kohsuke").getOrganizations();
+        System.out.println(o);
+    }
+
+    @Test
+    public void testOrgTeams() throws Exception {
+        kohsuke();
+        int sz=0;
+        for (GHTeam t : gitHub.getOrganization("github-api-test-org").listTeams()) {
+            assertNotNull(t.getName());
+            sz++;
+        }
+        assertTrue(sz<100);
+    }
+
+    @Test
+    public void testOrgTeamByName() throws Exception {
+        kohsuke();
+        GHTeam e = gitHub.getOrganization("github-api-test-org").getTeamByName("Core Developers");
+        assertNotNull(e);
+    }
+
+    @Test
+    public void testCommit() throws Exception {
+        GHCommit commit = gitHub.getUser("jenkinsci").getRepository("jenkins").getCommit("08c1c9970af4d609ae754fbe803e06186e3206f7");
+        System.out.println(commit);
+        assertEquals(1, commit.getParents().size());
+        assertEquals(1,commit.getFiles().size());
+
+        File f = commit.getFiles().get(0);
+        assertEquals(48,f.getLinesChanged());
+        assertEquals("modified",f.getStatus());
+        assertEquals("changelog.html", f.getFileName());
+    }
+
+    @Test
+    public void testListCommits() throws Exception {
+        List<String> sha1 = new ArrayList<String>();
+        for (GHCommit c : gitHub.getUser("kohsuke").getRepository("empty-commit").listCommits()) {
+            System.out.println(c.getSHA1());
+            sha1.add(c.getSHA1());
+        }
+        assertEquals("fdfad6be4db6f96faea1f153fb447b479a7a9cb7", sha1.get(0));
+        assertEquals(1, sha1.size());
+    }
+
+    public void testQueryCommits() throws Exception {
+        List<String> sha1 = new ArrayList<String>();
+        for (GHCommit c : gitHub.getUser("jenkinsci").getRepository("jenkins").queryCommits()
+                .since(new Date(1199174400000L)).until(1201852800000L).path("pom.xml").list()) {
+            System.out.println(c.getSHA1());
+            sha1.add(c.getSHA1());
+        }
+        assertEquals("1cccddb22e305397151b2b7b87b4b47d74ca337b",sha1.get(0));
+        assertEquals(29,sha1.size());
+    }
+
+    @Test
+    public void testBranches() throws Exception {
+        Map<String,GHBranch> b =
+                gitHub.getUser("jenkinsci").getRepository("jenkins").getBranches();
+        System.out.println(b);
+    }
+
+    @Test
+    public void testCommitComment() throws Exception {
+        GHRepository r = gitHub.getUser("jenkinsci").getRepository("jenkins");
+        PagedIterable<GHCommitComment> comments = r.listCommitComments();
+        List<GHCommitComment> batch = comments.iterator().nextPage();
+        for (GHCommitComment comment : batch) {
+            System.out.println(comment.getBody());
+            assertSame(comment.getOwner(), r);
+        }
+    }
+
+    @Test
+    public void testCreateCommitComment() throws Exception {
+        GHCommit commit = gitHub.getUser("kohsuke").getRepository("sandbox-ant").getCommit("8ae38db0ea5837313ab5f39d43a6f73de3bd9000");
+        GHCommitComment c = commit.createComment("[testing](http://kohsuse.org/)");
+        System.out.println(c);
+        c.update("updated text");
+        System.out.println(c);
+        c.delete();
+    }
+
+    @Test
+    public void tryHook() throws Exception {
+        kohsuke();
+        GHRepository r = gitHub.getMyself().getRepository("test2");
+        GHHook hook = r.createWebHook(new URL("http://www.google.com/"));
+        System.out.println(hook);
+
+        for (GHHook h : r.getHooks())
+            h.delete();
+    }
+    
+    @Test
+    public void testEventApi() throws Exception {
+        for (GHEventInfo ev : gitHub.getEvents()) {
+            System.out.println(ev);
+            if (ev.getType()==GHEvent.PULL_REQUEST) {
+                GHEventPayload.PullRequest pr = ev.getPayload(GHEventPayload.PullRequest.class);
+                System.out.println(pr.getNumber());
+                System.out.println(pr.getPullRequest());
+            }
+        }
+    }
+
+    @Test
+    public void testApp() throws IOException {
+        System.out.println(gitHub.getMyself().getEmails());
+
+//        GHRepository r = gitHub.getOrganization("jenkinsci").createRepository("kktest4", "Kohsuke's test", "http://kohsuke.org/", "Everyone", true);
+//        r.fork();
+
+//        tryDisablingIssueTrackers(gitHub);
+
+//        tryDisablingWiki(gitHub);
+
+//        GHPullRequest i = gitHub.getOrganization("jenkinsci").getRepository("sandbox").getPullRequest(1);
+//        for (GHIssueComment c : i.getComments())
+//            System.out.println(c);
+//        System.out.println(i);
+
+//        gitHub.getMyself().getRepository("perforce-plugin").setEmailServiceHook("kk@kohsuke.org");
+
+//        tryRenaming(gitHub);
+//        tryOrgFork(gitHub);
+
+//        testOrganization(gitHub);
+//        testPostCommitHook(gitHub);
+
+//        tryTeamCreation(gitHub);
+
+//        t.add(gitHub.getMyself());
+//        System.out.println(t.getMembers());
+//        t.remove(gitHub.getMyself());
+//        System.out.println(t.getMembers());
+
+//        GHRepository r = gitHub.getOrganization("HudsonLabs").createRepository("auto-test", "some description", "http://kohsuke.org/", "Plugin Developers", true);
+
+//        r.
+//        GitHub hub = GitHub.connectAnonymously();
+////        hub.createRepository("test","test repository",null,true);
+////        hub.getUser("kohsuke").getRepository("test").delete();
+//
+//        System.out.println(hub.getUser("kohsuke").getRepository("hudson").getCollaborators());
+    }
+
+    private void tryDisablingIssueTrackers(GitHub gitHub) throws IOException {
+        for (GHRepository r : gitHub.getOrganization("jenkinsci").getRepositories().values()) {
+            if (r.hasIssues()) {
+                if (r.getOpenIssueCount()==0) {
+                    System.out.println("DISABLED  "+r.getName());
+                    r.enableIssueTracker(false);
+                } else {
+                    System.out.println("UNTOUCHED "+r.getName());
+                }
+            }
+        }
+    }
+
+    private void tryDisablingWiki(GitHub gitHub) throws IOException {
+        for (GHRepository r : gitHub.getOrganization("jenkinsci").getRepositories().values()) {
+            if (r.hasWiki()) {
+                System.out.println("DISABLED  "+r.getName());
+                r.enableWiki(false);
+            }
+        }
+    }
+
+    private void tryUpdatingIssueTracker(GitHub gitHub) throws IOException {
+        GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("lib-task-reactor");
+        System.out.println(r.hasIssues());
+        System.out.println(r.getOpenIssueCount());
+        r.enableIssueTracker(false);
+    }
+
+    private void tryRenaming(GitHub gitHub) throws IOException {
+        gitHub.getUser("kohsuke").getRepository("test").renameTo("test2");
+    }
+
+    private void tryTeamCreation(GitHub gitHub) throws IOException {
+        GHOrganization o = gitHub.getOrganization("HudsonLabs");
+        GHTeam t = o.createTeam("auto team", Permission.PUSH);
+        t.add(o.getRepository("auto-test"));
+    }
+
+    private void testPostCommitHook(GitHub gitHub) throws IOException {
+        GHRepository r = gitHub.getMyself().getRepository("foo");
+        Set<URL> hooks = r.getPostCommitHooks();
+        hooks.add(new URL("http://kohsuke.org/test"));
+        System.out.println(hooks);
+        hooks.remove(new URL("http://kohsuke.org/test"));
+        System.out.println(hooks);
+    }
+
+    @Test
+    public void testOrgRepositories() throws IOException {
+        kohsuke();
+        GHOrganization j = gitHub.getOrganization("jenkinsci");
+        long start = System.currentTimeMillis();
+        Map<String, GHRepository> repos = j.getRepositories();
+        long end = System.currentTimeMillis();
+        System.out.printf("%d repositories in %dms\n",repos.size(),end-start);
+    }
+    
+    @Test
+    public void testOrganization() throws IOException {
+        kohsuke();
+        GHOrganization j = gitHub.getOrganization("github-api-test-org");
+        GHTeam t = j.getTeams().get("Core Developers");
+
+        assertNotNull(j.getRepository("jenkins"));
+
+//        t.add(labs.getRepository("xyz"));
+    }
+
+    @Test
+    public void testCommitStatus() throws Exception {
+        GHRepository r = gitHub.getRepository("kohsuke/github-api");
+
+        GHCommitStatus state;
+
+//        state = r.createCommitStatus("ecbfdd7315ef2cf04b2be7f11a072ce0bd00c396", GHCommitState.FAILURE, "http://kohsuke.org/", "testing!");
+
+        List<GHCommitStatus> lst = r.listCommitStatuses("ecbfdd7315ef2cf04b2be7f11a072ce0bd00c396").asList();
+        state = lst.get(0);
+        System.out.println(state);
+        assertEquals("testing!",state.getDescription());
+        assertEquals("http://kohsuke.org/",state.getTargetUrl());
+    }
+    
+    @Test
+    public void testCommitShortInfo() throws Exception {
+        GHRepository r = gitHub.getRepository("kohsuke/github-api");
+        GHCommit commit = r.getCommit("86a2e245aa6d71d54923655066049d9e21a15f23");
+        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Kohsuke Kawaguchi");
+        assertEquals(commit.getCommitShortInfo().getMessage(), "doc");
+    }
+
+    @Test
+    public void testPullRequestPopulate() throws Exception {
+        GHRepository r = gitHub.getUser("kohsuke").getRepository("github-api");
+        GHPullRequest p = r.getPullRequest(17);
+        GHUser u = p.getUser();
+        assertNotNull(u.getName());
+    }
+
+    @Test
+    public void testCheckMembership() throws Exception {
+        kohsuke();
+        GHOrganization j = gitHub.getOrganization("jenkinsci");
+        GHUser kohsuke = gitHub.getUser("kohsuke");
+        GHUser b = gitHub.getUser("b");
+
+        assertTrue(j.hasMember(kohsuke));
+        assertFalse(j.hasMember(b));
+
+        assertTrue(j.hasPublicMember(kohsuke));
+        assertFalse(j.hasPublicMember(b));
+    }
+
+    @Test
+    public void testCreateRelease() throws Exception {
+        kohsuke();
+
+        GHRepository r = gitHub.getRepository("kohsuke2/testCreateRelease");
+
+        String tagName = UUID.randomUUID().toString();
+        String releaseName = "release-" + tagName;
+
+        GHRelease rel = r.createRelease(tagName)
+                .name(releaseName)
+                .prerelease(false)
+                .create();
+
+        try {
+
+            for (GHTag tag : r.listTags()) {
+                if (tagName.equals(tag.getName())) {
+                    String ash = tag.getCommit().getSHA1();
+                    GHRef ref = r.createRef("refs/heads/"+releaseName, ash);
+                    assertEquals(ref.getRef(),"refs/heads/"+releaseName);
+
+                    for (Map.Entry<String, GHBranch> entry : r.getBranches().entrySet()) {
+                        System.out.println(entry.getKey() + "/" + entry.getValue());
+                        if (releaseName.equals(entry.getValue().getName())) {
+                            return;
+                        }
+                    }
+                    fail("branch not found");
+                }
+            }
+            fail("release creation failed! tag not found");
+        } finally {
+            rel.delete();
+        }
+    }
+
+    @Test
+	public void testRef() throws IOException {
+		GHRef masterRef = gitHub.getRepository("jenkinsci/jenkins").getRef("heads/master");
+		assertEquals("https://api.github.com/repos/jenkinsci/jenkins/git/refs/heads/master", masterRef.getUrl().toString());
+	}
+
+    @Test
+    public void directoryListing() throws IOException {
+        List<GHContent> children = gitHub.getRepository("jenkinsci/jenkins").getDirectoryContent("core");
+        for (GHContent c : children) {
+            System.out.println(c.getName());
+            if (c.isDirectory()) {
+                for (GHContent d : c.listDirectoryContent()) {
+                    System.out.println("  "+d.getName());
+                }
+            }
+        }
+    }
+    
+    @Test
+    public void testAddDeployKey() throws IOException {
+    	GHRepository myRepository = Iterables.get(gitHub.getMyself().getRepositories().values(),0);
+    	final GHDeployKey newDeployKey = myRepository.addDeployKey("test", "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC55wA5wHqTFMk3OkyHqtmgSAmIanREVP4ukMrPZFzYfRBaKYPCbBRxu7ddzF3oZ+i6ZV8+rH8hvhQTYl5LtOIxLUppsVVNSB9YKXQv37LLaWul9WoJPdXHGWfR3wlhRXsg1sMPpbgu60lXAl7xvx729FEjKEEHRMGkPbcIeHkov/tlEg9oQdqFC1Pqnv/lCsZ5UKRPLHY3V9pmSaEplwmwb//HppNtEYr9t6VNvOMjqbUrbhsilKu0t6qa3G7Kb47kvfJwMn+DKD2XJMYHYHMyHtHcFK8RIOSX8I+Bu4yeVmvcooSL65FBCIrmVoejkI7gZWDfgWVRboQ9RyB+VeXL example@example.com");
+    	assertNotNull(newDeployKey.getId());
+    	
+    	Iterables.find( myRepository.getDeployKeys(),new Predicate<GHDeployKey>() {
+    		 public boolean apply(GHDeployKey deployKey) {
+    			  return newDeployKey.getId() == deployKey.getId() ;
+    		  }
+		});
+    	newDeployKey.delete();
+    }
+
+    private void kohsuke() {
+        String login = getUser().getLogin();
+        Assume.assumeTrue(login.equals("kohsuke") || login.equals("kohsuke2"));
+    }
+}

src/test/java/org/kohsuke/github/GHContentIntegrationTest.java

@@ -0,0 +1,68 @@
+package org.kohsuke.github;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * Integration test for {@link GHContent}.
+ */
+public class GHContentIntegrationTest extends AbstractGitHubApiTestBase {
+
+    private GHRepository repo;
+    private String createdFilename = rnd.next();
+
+    @Before
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        repo = gitHub.getRepository("github-api-test-org/GHContentIntegrationTest").fork();
+    }
+
+    @Test
+    public void testGetFileContent() throws Exception {
+        GHContent content = repo.getFileContent("ghcontent-ro/a-file-with-content");
+
+        assertTrue(content.isFile());
+        assertEquals("thanks for reading me\n", content.getContent());
+    }
+
+    @Test
+    public void testGetEmptyFileContent() throws Exception {
+        GHContent content = repo.getFileContent("ghcontent-ro/an-empty-file");
+
+        assertTrue(content.isFile());
+        assertEquals("", content.getContent());
+    }
+
+    @Test
+    public void testGetDirectoryContent() throws Exception {
+        List<GHContent> entries = repo.getDirectoryContent("ghcontent-ro/a-dir-with-3-entries");
+
+        assertTrue(entries.size() == 3);
+    }
+
+    @Test
+    public void testCRUDContent() throws Exception {
+        GHContentUpdateResponse created = repo.createContent("this is an awesome file I created\n", "Creating a file for integration tests.", createdFilename);
+        GHContent createdContent = created.getContent();
+
+        assertNotNull(created.getCommit());
+        assertNotNull(created.getContent());
+        assertNotNull(createdContent.getContent());
+        assertEquals("this is an awesome file I created\n", createdContent.getContent());
+
+        GHContentUpdateResponse updatedContentResponse = createdContent.update("this is some new content\n", "Updated file for integration tests.");
+        GHContent updatedContent = updatedContentResponse.getContent();
+
+        assertNotNull(updatedContentResponse.getCommit());
+        assertNotNull(updatedContentResponse.getContent());
+        assertEquals("this is some new content\n", updatedContent.getContent());
+
+        GHContentUpdateResponse deleteResponse = updatedContent.delete("Enough of this foolishness!");
+
+        assertNotNull(deleteResponse.getCommit());
+        assertNull(deleteResponse.getContent());
+    }
+}

src/test/java/org/kohsuke/github/GistTest.java

@@ -0,0 +1,73 @@
+package org.kohsuke.github;
+
+import org.junit.Test;
+
+/**
+ * @author Kohsuke Kawaguchi
+ */
+public class GistTest extends AbstractGitHubApiTestBase {
+    /**
+     * CRUD operation.
+     */
+    @Test
+    public void lifecycleTest() throws Exception {
+        GHGist gist = gitHub.createGist()
+                .public_(false)
+                .description("Test Gist")
+                .file("abc.txt","abc")
+                .file("def.txt","def")
+                .create();
+
+        assertNotNull(gist.getCreatedAt());
+        assertNotNull(gist.getUpdatedAt());
+
+        assertNotNull(gist.getCommentsUrl());
+        assertNotNull(gist.getCommitsUrl());
+        assertNotNull(gist.getGitPullUrl());
+        assertNotNull(gist.getGitPushUrl());
+        assertNotNull(gist.getHtmlUrl());
+
+        gist.delete();
+    }
+
+    @Test
+    public void starTest() throws Exception {
+        GHGist gist = gitHub.getGist("9903708");
+        assertEquals("rtyler",gist.getOwner().getLogin());
+
+        gist.star();
+        assertTrue(gist.isStarred());
+        gist.unstar();
+        assertFalse(gist.isStarred());
+
+        GHGist newGist = gist.fork();
+
+        try {
+            for (GHGist g : gist.listForks()) {
+                if (g.equals(newGist)) {
+                    // expected to find it in the clone list
+                    return;
+                }
+            }
+
+            fail("Expected to find a newly cloned gist");
+        } finally {
+            newGist.delete();
+        }
+    }
+
+    @Test
+    public void gistFile() throws Exception {
+        GHGist gist = gitHub.getGist("9903708");
+
+        assertTrue(gist.isPublic());
+
+        assertEquals(1,gist.getFiles().size());
+        GHGistFile f = gist.getFile("keybase.md");
+
+        assertEquals("text/plain", f.getType());
+        assertEquals("Markdown", f.getLanguage());
+        assertTrue(f.getContent().contains("### Keybase proof"));
+        assertNotNull(f.getContent());
+    }
+}

src/test/java/org/kohsuke/github/GitHubTest.java

@@ -0,0 +1,24 @@
+package org.kohsuke.github;
+
+import junit.framework.TestCase;
+
+/**
+ * Unit test for {@link GitHub}.
+ */
+public class GitHubTest extends TestCase {
+
+    public void testGitHubServerWithHttp() throws Exception {
+        GitHub hub = GitHub.connectToEnterprise("http://enterprise.kohsuke.org/api/v3", "bogus","bogus");
+        assertEquals("http://enterprise.kohsuke.org/api/v3/test", hub.getApiURL("/test").toString());
+    }
+
+    public void testGitHubServerWithHttps() throws Exception {
+        GitHub hub = GitHub.connectToEnterprise("https://enterprise.kohsuke.org/api/v3", "bogus","bogus");
+        assertEquals("https://enterprise.kohsuke.org/api/v3/test", hub.getApiURL("/test").toString());
+    }
+
+    public void testGitHubServerWithoutServer() throws Exception {
+        GitHub hub = GitHub.connectUsingPassword("kohsuke", "bogus");
+        assertEquals("https://api.github.com/test", hub.getApiURL("/test").toString());
+    }
+}

src/test/java/org/kohsuke/github/LifecycleTest.java

@@ -0,0 +1,135 @@
+package org.kohsuke.github;
+
+import org.apache.commons.io.IOUtils;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.dircache.DirCache;
+import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.List;
+import java.util.Properties;
+
+public class LifecycleTest extends AbstractGitHubApiTestBase {
+    @Test
+    public void testCreateRepository() throws IOException, GitAPIException, InterruptedException {
+        GHMyself myself = gitHub.getMyself();
+        GHOrganization org = gitHub.getOrganization("github-api-test-org");
+        GHRepository repository = org.getRepository("github-api-test");
+        if (repository != null) {
+            repository.delete();
+            Thread.sleep(1000);
+        }
+        repository = org.createRepository("github-api-test",
+                "a test repository used to test kohsuke's github-api", "http://github-api.kohsuke.org/", "Core Developers", true);
+        Thread.sleep(1000); // wait for the repository to become ready
+
+        assertTrue(repository.getReleases().isEmpty());
+        try {
+            GHMilestone milestone = repository.createMilestone("Initial Release", "first one");
+            GHIssue issue = repository.createIssue("Test Issue")
+                    .body("issue body just for grins")
+                    .milestone(milestone)
+                    .assignee(myself)
+                    .label("bug")
+                    .create();
+            File repoDir = new File(System.getProperty("java.io.tmpdir"), "github-api-test");
+            delete(repoDir);
+            Git origin = Git.cloneRepository()
+                    .setBare(false)
+                    .setURI(repository.getSshUrl())
+                    .setDirectory(repoDir)
+                    .setCredentialsProvider(getCredentialsProvider(myself))
+                    .call();
+
+            commitTestFile(myself, repoDir, origin);
+
+
+            GHRelease release = createRelease(repository);
+
+            GHAsset asset = uploadAsset(release);
+
+            updateAsset(release, asset);
+
+            deleteAsset(release, asset);
+        } finally {
+            repository.delete();
+        }
+    }
+
+    private void updateAsset(GHRelease release, GHAsset asset) throws IOException {
+        asset.setLabel("test label");
+        assertEquals("test label", release.getAssets().get(0).getLabel());
+    }
+
+    private void deleteAsset(GHRelease release, GHAsset asset) throws IOException {
+        asset.delete();
+        assertEquals(0, release.getAssets().size());
+    }
+
+    private GHAsset uploadAsset(GHRelease release) throws IOException {
+        GHAsset asset = release.uploadAsset(new File("pom.xml"), "application/text");
+        assertNotNull(asset);
+        List<GHAsset> assets = release.getAssets();
+        assertEquals(1, assets.size());
+        assertEquals("pom.xml", assets.get(0).getName());
+
+        return asset;
+    }
+
+    private GHRelease createRelease(GHRepository repository) throws IOException {
+        GHRelease builder = repository.createRelease("release_tag")
+                .name("Test Release")
+                .body("How exciting!  To be able to programmatically create releases is a dream come true!")
+                .create();
+        List<GHRelease> releases = repository.getReleases();
+        assertEquals(1, releases.size());
+        GHRelease release = releases.get(0);
+        assertEquals("Test Release", release.getName());
+        return release;
+    }
+
+    private void commitTestFile(GHMyself myself, File repoDir, Git origin) throws IOException, GitAPIException {
+        File dummyFile = createDummyFile(repoDir);
+        DirCache cache = origin.add().addFilepattern(dummyFile.getName()).call();
+        origin.commit().setMessage("test commit").call();
+        origin.push().setCredentialsProvider(getCredentialsProvider(myself)).call();
+    }
+
+    private UsernamePasswordCredentialsProvider getCredentialsProvider(GHMyself myself) throws IOException {
+        Properties props = new Properties();
+        File homeDir = new File(System.getProperty("user.home"));
+        FileInputStream in = new FileInputStream(new File(homeDir, ".github"));
+        try {
+            props.load(in);
+        } finally {
+            IOUtils.closeQuietly(in);
+        }
+        return new UsernamePasswordCredentialsProvider(props.getProperty("login"), props.getProperty("oauth"));
+    }
+
+    private void delete(File toDelete) {
+        if (toDelete.isDirectory()) {
+            for (File file : toDelete.listFiles()) {
+                delete(file);
+            }
+        }
+        toDelete.delete();
+    }
+
+    private File createDummyFile(File repoDir) throws IOException {
+        File file = new File(repoDir, "testFile-" + System.currentTimeMillis());
+        PrintWriter writer = new PrintWriter(new FileWriter(file));
+        try {
+            writer.println("test file");
+        } finally {
+            writer.close();
+        }
+        return file;
+    }
+}

src/test/java/org/kohsuke/github/PullRequestTest.java

@@ -0,0 +1,18 @@
+package org.kohsuke.github;
+
+import org.junit.Test;
+
+/**
+ * @author Kohsuke Kawaguchi
+ */
+public class PullRequestTest extends AbstractGitHubApiTestBase {
+    @Test
+    public void createPullRequest() throws Exception {
+        GHRepository j = gitHub.getOrganization("github-api-test-org").getRepository("jenkins");
+        String name = rnd.next();
+        GHPullRequest p = j.createPullRequest(name, "stable", "master", "## test");
+        System.out.println(p.getUrl());
+        assertEquals(name, p.getTitle());
+        p.close();
+    }
+}