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

Conflicts:
	src/main/java/org/kohsuke/github/GHOrganization.java
	src/main/java/org/kohsuke/github/Requester.java
	src/test/java/org/kohsuke/AppTest.java

.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.

pom.xml

@@ -3,11 +3,11 @@
   <parent>
     <groupId>org.kohsuke</groupId>
     <artifactId>pom</artifactId>
-    <version>3</version>
+    <version>6</version>
   </parent>
 
   <artifactId>github-api</artifactId>
-  <version>1.34</version>
+  <version>1.52</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.8</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.9.9</version>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.2.3</version>
     </dependency>
     <dependency>
       <groupId>commons-io</groupId>
@@ -74,7 +77,7 @@
     <dependency>
       <groupId>com.infradna.tool</groupId>
       <artifactId>bridge-method-annotation</artifactId>
-      <version>1.4</version>
+      <version>1.8</version>
       <optional>true</optional>
     </dependency>
     <dependency>
@@ -83,14 +86,31 @@
       <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>
   </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>
@@ -100,4 +120,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/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/GHCommit.java

@@ -1,5 +1,7 @@
 package org.kohsuke.github;
 
+import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
+
 import java.io.IOException;
 import java.net.URL;
 import java.util.AbstractList;
@@ -16,6 +18,47 @@ import java.util.List;
  */
 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;
@@ -110,8 +153,14 @@ public class GHCommit {
     Stats stats;
     List<Parent> parents;
     User author,committer;
+    
+    
 
-    /**
+    public ShortInfo getCommitShortInfo() {
+		return commit;
+	}
+
+	/**
      * The repository that contains the commit.
      */
     public GHRepository getOwner() {

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/*V2*/,repo/*V3*/;
+    private GHRepository repo;
 
     /**
      * This points to the user who owns
-     * the {@link #repository}.
+     * the {@link #getRepository()}.
      */
     public GHUser getUser() {
         return user;
@@ -45,7 +45,7 @@ public class GHCommitPointer {
      * The repository that contains the commit.
      */
     public GHRepository getRepository() {
-        return repo!=null ? repo : repository;
+        return repo;
     }
 
     /**
@@ -72,6 +72,5 @@ public class GHCommitPointer {
     void wrapUp(GitHub root) {
         if (user!=null) user.root = root;
         if (repo!=null) repo.wrap(root);
-        if (repository!=null) repository.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/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,171 @@
+package org.kohsuke.github;
+
+import java.io.IOException;
+
+import javax.xml.bind.DatatypeConverter;
+
+/**
+ * A Content of a repository.
+ *
+ * @author Alexandre COLLIGNON
+ */
+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);
+    }
+
+    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/GHEmail.java

@@ -0,0 +1,69 @@
+/*
+ * 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;
+
+
+/**
+ * Represents an email of GitHub.
+ *
+ * @author Kelly Campbell
+ */
+public class GHEmail {
+
+    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 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

@@ -1,10 +1,10 @@
 package org.kohsuke.github;
 
-import org.codehaus.jackson.node.ObjectNode;
-
 import java.io.IOException;
 import java.util.Date;
 
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
 /**
  * Represents an event.
  *
@@ -63,6 +63,13 @@ public class GHEventInfo {
         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());
     }

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

@@ -1,6 +1,7 @@
 package org.kohsuke.github;
 
 import java.io.Reader;
+import java.util.List;
 
 /**
  * Base type for types used in databinding of the event payload.
@@ -8,6 +9,7 @@ import java.io.Reader;
  * @see GitHub#parseEventPayload(Reader, Class)
  * @see GHEventInfo#getPayload(Class)
  */
+@SuppressWarnings("UnusedDeclaration")
 public abstract class GHEventPayload {
     protected GitHub root;
 
@@ -18,10 +20,16 @@ public abstract class GHEventPayload {
         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;
-        GHPullRequest pull_request;
+        private GHPullRequest pull_request;
+        private GHRepository repository;
 
         public String getAction() {
             return action;
@@ -36,11 +44,153 @@ public abstract class GHEventPayload {
             return pull_request;
         }
 
+        public GHRepository getRepository() {
+            return repository;
+        }
+
         @Override
         void wrapUp(GitHub root) {
             super.wrapUp(root);
-            pull_request.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/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;
     }
 

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

@@ -49,7 +49,7 @@ public class GHIssue {
     protected String closed_at;
     protected int comments;
     protected String body;
-    protected List<String> labels;
+    protected List<Label> labels;
     protected GHUser user;
     protected String title, created_at, html_url;
     protected GHIssue.PullRequest pull_request;
@@ -58,6 +58,24 @@ public class GHIssue {
     protected int id;
     protected GHUser closed_by;
 
+    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;
@@ -111,7 +129,7 @@ public class GHIssue {
         return Enum.valueOf(GHIssueState.class, state.toUpperCase(Locale.ENGLISH));
     }
 
-    public Collection<String> getLabels() {
+    public Collection<Label> getLabels() {
         if(labels == null){
             return Collections.EMPTY_LIST;
         }
@@ -138,7 +156,7 @@ public class GHIssue {
      * Updates the issue by adding a comment.
      */
     public void comment(String message) throws IOException {
-        new Requester(root).with("body",message).to(getApiRoute() + "/comments");
+        new Requester(root).with("body",message).to(getIssuesApiRoute() + "/comments");
     }
 
     private void edit(String key, Object value) throws IOException {
@@ -172,7 +190,7 @@ public class GHIssue {
     }
 
     public void setLabels(String... labels) throws IOException {
-        edit("assignee",labels);
+        edit("labels",labels);
     }
 
     /**
@@ -190,7 +208,7 @@ public class GHIssue {
     public PagedIterable<GHIssueComment> listComments() throws IOException {
         return new PagedIterable<GHIssueComment>() {
             public PagedIterator<GHIssueComment> iterator() {
-                return new PagedIterator<GHIssueComment>(root.retrieve().asIterator(getApiRoute() + "/comments", GHIssueComment[].class)) {
+                return new PagedIterator<GHIssueComment>(root.retrieve().asIterator(getIssuesApiRoute() + "/comments", GHIssueComment[].class)) {
                     protected void wrapUp(GHIssueComment[] page) {
                         for (GHIssueComment c : page)
                             c.wrapUp(GHIssue.this);
@@ -200,7 +218,11 @@ public class GHIssue {
         };
     }
 
-    private String getApiRoute() {
+    protected String getApiRoute() {
+        return getIssuesApiRoute();
+    }
+
+    private String getIssuesApiRoute() {
         return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/issues/"+number;
     }
 
@@ -250,4 +272,4 @@ public class GHIssue {
 			return GitHub.parseURL(html_url);
 		}
 	}
-}
+}

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

@@ -10,9 +10,9 @@ import org.apache.commons.lang.builder.ToStringBuilder;
 public class GHKey {
     /*package almost final*/ GitHub root;
 
-    private String url, key, title;
-    private boolean verified;
-    private int id;
+    protected String url, key, title;
+    protected boolean verified;
+    protected int id;
 
     public int getId() {
         return id;

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

@@ -1,5 +1,6 @@
 package org.kohsuke.github;
 
+import java.io.IOException;
 import java.util.Date;
 import java.util.Locale;
 
@@ -65,6 +66,21 @@ public class GHMilestone {
 		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;

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

@@ -1,9 +1,15 @@
 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.
@@ -11,31 +17,105 @@ import java.util.List;
  * @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<String> getEmails() throws IOException {
-        String[] addresses = root.retrieve().to("/user/emails", String[].class);
+    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.
+     */
+    public PagedIterable<GHRepository> listAllRepositories() {
+        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);
+                    }
+                };
+            }
+        };
+    }
+
 //    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,11 +1,6 @@
 package org.kohsuke.github;
 
-import com.gargoylesoftware.htmlunit.WebClient;
-import com.gargoylesoftware.htmlunit.html.HtmlAnchor;
-import com.gargoylesoftware.htmlunit.html.HtmlPage;
-
 import java.io.IOException;
-import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -28,10 +23,15 @@ 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 Requester(root)
                 .with("name", name).with("description", description).with("homepage", homepage)
@@ -42,14 +42,73 @@ public class GHOrganization extends GHPerson {
      * Teams by their names.
      */
     public Map<String,GHTeam> getTeams() throws IOException {
-        GHTeam[] teams = root.retrieve().to("/orgs/" + login + "/teams", GHTeam[].class);
         Map<String,GHTeam> r = new TreeMap<String, GHTeam>();
-        for (GHTeam t : teams) {
-            r.put(t.getName(),t.wrapUp(this));
+        for (GHTeam t : listTeams()) {
+            r.put(t.getName(),t);
         }
         return r;
     }
 
+    /**
+     * 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 {
+            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;
+        }
+    }
+
     /**
      * Publicizes the membership.
      */
@@ -58,26 +117,44 @@ public class GHOrganization extends GHPerson {
     }
 
     /**
-     * All the members of this organization.
+     * @deprecated use {@link #listMembers()}
      */
     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.retrieve().to("/orgs/" + login + "/members", GHUser[].class);
+        return listMembers().asList();
+    }
 
-            @Override
-            public GHUser get(int index) {
-                try {
-                    return root.getUser(shallow[index].getLogin());
-                } catch (IOException e) {
-                    throw new RuntimeException(e);
-                }
-            }
+    /**
+     * All the members of this organization.
+     */
+    public PagedIterable<GHUser> listMembers() throws IOException {
+        return listMembers("members");
+    }
 
-            @Override
-            public int size() {
-                return shallow.length;
+    /**
+     * All the public members of this organization.
+     */
+    public PagedIterable<GHUser> listPublicMembers() throws IOException {
+        return listMembers("public_members");
+    }
+
+    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);
+                    }
+                };
             }
         };
     }
@@ -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

@@ -54,6 +54,36 @@ public abstract class GHPerson {
         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.
      * 
@@ -63,6 +93,9 @@ public abstract class GHPerson {
      * 
      * 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>>() {
@@ -102,6 +135,11 @@ public abstract class GHPerson {
         }
     }
 
+    /**
+     * Lists events for an organization or an user.
+     */
+    public abstract PagedIterable<GHEventInfo> listEvents() throws IOException;
+
     /**
      * Gravatar ID of this user, like 0cb9832a01c22c083390f3c5dcb64105
      *
@@ -202,5 +240,4 @@ public abstract class GHPerson {
         populate();
         return followers;
     }
-
 }

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

@@ -27,11 +27,13 @@ import java.io.IOException;
 import java.net.URL;
 import java.util.Collection;
 import java.util.Date;
+import java.util.Locale;
 
 /**
  * A pull request.
  * 
  * @author Kohsuke Kawaguchi
+ * @see GHRepository#getPullRequest(int)
  */
 @SuppressWarnings({"UnusedDeclaration"})
 public class GHPullRequest extends GHIssue {
@@ -63,7 +65,12 @@ public class GHPullRequest extends GHIssue {
         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.
      * like https://github.com/jenkinsci/jenkins/pull/100.patch
@@ -113,7 +120,7 @@ public class GHPullRequest extends GHIssue {
     }
 
 	@Override
-	public Collection<String> getLabels() {
+	public Collection<Label> getLabels() {
 		return super.getLabels();
 	}
 
@@ -181,4 +188,34 @@ public class GHPullRequest extends GHIssue {
 
         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/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,213 @@
+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(owner.getApiTailUrl(format("releases/%d/assets", id)), GHAsset[].class);
+        return Arrays.asList(GHAsset.wrap(assets, this));
+    }
+}

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,14 +23,10 @@
  */
 package org.kohsuke.github;
 
-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.io.InterruptedIOException;
 import java.net.URL;
@@ -64,12 +60,14 @@ public class GHRepository {
     private String url; // this is the API url
     private String html_url;    // this is the UI
     private GHUser owner;   // not fully populated. beware.
-    private boolean has_issues, has_wiki, fork, _private, has_downloads;
-    private int watchers,forks,open_issues,size;
+    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 master_branch,language;
+    private String default_branch,language;
     private Map<String,GHCommit> commits = new HashMap<String, GHCommit>();
 
     private GHRepoPermission permissions;
@@ -149,7 +147,41 @@ public class GHRepository {
     }
 
     public List<GHIssue> getIssues(GHIssueState state) throws IOException {
-        return Arrays.asList(GHIssue.wrap(root.retrieve().to("/repos/" + owner.login + "/" + name + "/issues?state=" + state.toString().toLowerCase(), GHIssue[].class), 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);
+    }
+
+    public List<GHRelease> getReleases() throws IOException {
+        return Arrays.asList(GHRelease.wrap(root.retrieve().to("/repos/" + owner.login + "/" + name + "/releases",
+                GHRelease[].class), this));
     }
 
     protected String getOwnerName() {
@@ -188,6 +220,14 @@ public class GHRepository {
         return open_issues;
     }
 
+    public int getNetworkCount() {
+        return network_count;
+    }
+
+    public int getSubscribersCount() {
+        return subscribers_count;
+    }
+
     /**
      *
      * @return
@@ -208,7 +248,7 @@ public class GHRepository {
      *      This field is null until the user explicitly configures the master branch.
      */
     public String getMasterBranch() {
-        return master_branch;
+        return default_branch;
     }
 
     public int getSize() {
@@ -266,15 +306,10 @@ public class GHRepository {
     }
 
     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);
-
-        final HtmlForm f = email.getEnclosingFormOrDie();
-        f.submit((HtmlButton) f.getElementsByTagName("button").get(0));
+        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));
     }
 
     private void edit(String key, String value) throws IOException {
@@ -404,6 +439,46 @@ public class GHRepository {
         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);
+    }
+
     /**
      * Gets a commit object in this repository.
      */
@@ -432,6 +507,13 @@ public class GHRepository {
         };
     }
 
+    /**
+     * 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.
      */
@@ -490,6 +572,22 @@ public class GHRepository {
                 .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);
+                    }
+                };
+            }
+        };
+    }
 
     /**
      * 
@@ -662,7 +760,66 @@ public class GHRepository {
 		}
 		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);

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

@@ -49,6 +49,18 @@ public class GHTeam {
         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 {
         GHRepository[] repos = org.root.retrieve().to(api("/repos"), GHRepository[].class);
         Map<String,GHRepository> m = new TreeMap<String, GHRepository>();

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

@@ -69,6 +69,27 @@ public class GHUser extends GHPerson {
         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;
@@ -89,6 +110,23 @@ public class GHUser extends GHPerson {
         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);
+                    }
+                };
+            }
+        };
+    }
+
     @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,15 +23,7 @@
  */
 package org.kohsuke.github;
 
-import com.gargoylesoftware.htmlunit.WebClient;
-import com.gargoylesoftware.htmlunit.html.HtmlForm;
-import com.gargoylesoftware.htmlunit.html.HtmlPage;
-import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
-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;
@@ -42,6 +34,7 @@ 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;
@@ -49,7 +42,13 @@ import java.util.Map;
 import java.util.Properties;
 import java.util.TimeZone;
 
-import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.*;
+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.
@@ -58,54 +57,80 @@ import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.*;
  */
 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 final String apiUrl;
 
-	private GitHub(String login, String apiToken, String password) {
-		this ("https://api.github.com", login, apiToken, 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 apiToken, String password) {
+    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;
-		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;
+        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;
     }
 
-    private GitHub (String apiUrl, String oauthAccessToken) throws IOException {
-    	
-		this.apiUrl = apiUrl;
-		this.password = null;
-		this.encodedAuthorization = null;
-		
-		this.oauthAccessToken = oauthAccessToken;
-        this.apiToken = oauthAccessToken;
-		
-		this.login = getMyself().getLogin();
-    }
-    
     /**
      * Obtains the credential from "~/.github"
      */
@@ -118,7 +143,7 @@ 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"));
     }
 
     /**
@@ -129,51 +154,75 @@ public class GitHub {
      *      "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 login, String apiToken) {
-        // not exposing password because the login process still assumes https://github.com/
-        // if we are to fix this, fix that by getting rid of createWebClient() and replace the e-mail service hook
-        // with GitHub API.
-        return new GitHub(apiUrl,login,apiToken,null);
+    public static GitHub connectToEnterprise(String apiUrl, String oauthAccessToken) throws IOException {
+        return connectUsingOAuth(apiUrl, oauthAccessToken);
     }
 
-    public static GitHub connect(String login, String apiToken){
-        return new GitHub(login,apiToken,null);
+    public static GitHub connectToEnterprise(String apiUrl, String login, String password) throws IOException {
+        return new GitHub(apiUrl, login, null, password);
     }
 
-    public static GitHub connect(String login, String apiToken, String password){
-        return new GitHub(login,apiToken,password);
+    public static GitHub connect(String login, String oauthAccessToken) throws IOException {
+        return new GitHub(login,oauthAccessToken,null);
     }
 
-    public static GitHub connectUsingOAuth (String accessToken) throws IOException {
-    	return connectUsingOAuth("github.com", accessToken);
+    /**
+     * @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 connectUsingOAuth (String githubServer, String accessToken) throws IOException {
-    	return new GitHub(githubServer, accessToken);
+
+    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);
     }
 
+    /**
+     * Is this an anonymous connection
+     * @return {@code true} if operations that require authentication will fail.
+     */
+    public boolean isAnonymous() {
+        return login==null && encodedAuthorization==null;
+    }
+
+    public HttpConnector getConnector() {
+        return connector;
+    }
+
+    /**
+     * Sets the custom connector used to make requests to GitHub.
+     */
+    public void setConnector(HttpConnector connector) {
+        this.connector = connector;
+    }
+
     /*package*/ void requireCredential() {
-        if ((login==null || encodedAuthorization==null) && oauthAccessToken == null)
+        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 (oauthAccessToken != null) {
-    		// append the access token
-    		tailApiUrl = tailApiUrl +  (tailApiUrl.indexOf('?')>=0 ?'&':'?') + "access_token=" + oauthAccessToken;
-    	}
-
         if (tailApiUrl.startsWith("/")) {
             if ("github.com".equals(apiUrl)) {// backward compatibility
-                return new URL("https://api.github.com" + tailApiUrl);
+                return new URL(GITHUB_URL + tailApiUrl);
             } else {
                 return new URL(apiUrl + tailApiUrl);
             }
@@ -273,7 +322,7 @@ public class GitHub {
      * Public events visible to you. Equivalent of what's displayed on https://github.com/
      */
     public List<GHEventInfo> getEvents() throws IOException {
-        // TODO: pagenation
+        // TODO: pagination
         GHEventInfo[] events = retrieve().to("/events", GHEventInfo[].class);
         for (GHEventInfo e : events)
             e.wrapUp(this);
@@ -292,7 +341,7 @@ public class GitHub {
         t.wrapUp(this);
         return t;
     }
-    
+
     /**
      * Creates a new repository.
      *
@@ -306,6 +355,22 @@ public class GitHub {
         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.
      */
@@ -318,18 +383,6 @@ public class GitHub {
         }
     }
 
-    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);
@@ -352,12 +405,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/Requester.java

@@ -23,7 +23,7 @@
  */
 package org.kohsuke.github;
 
-import org.apache.commons.io.IOUtils;
+import static org.kohsuke.github.GitHub.MAPPER;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -31,21 +31,25 @@ 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 static org.kohsuke.github.GitHub.*;
+import org.apache.commons.io.IOUtils;
 
 /**
  * A builder pattern for making HTTP call and parsing its output.
@@ -60,6 +64,8 @@ class Requester {
      * Request method.
      */
     private String method = "POST";
+    private String contentType = "application/x-www-form-urlencoded";
+    private InputStream body;
 
     private static class Entry {
         String key;
@@ -107,6 +113,15 @@ class Requester {
         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));
@@ -119,6 +134,11 @@ class Requester {
         return this;
     }
 
+    public Requester contentType(String contentType) {
+        this.contentType = contentType;
+        return this;
+    }
+
     public void to(String tailApiUrl) throws IOException {
         to(tailApiUrl,null);
     }
@@ -156,13 +176,25 @@ class Requester {
 
             if (!method.equals("GET")) {
                 uc.setDoOutput(true);
-                uc.setRequestProperty("Content-type","application/x-www-form-urlencoded");
+                uc.setRequestProperty("Content-type", contentType);
 
-                Map json = new HashMap();
-                for (Entry e : args) {
-                    json.put(e.key, e.value);
+                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();
+                    }
                 }
-                MAPPER.writeValue(uc.getOutputStream(),json);
             }
 
             try {
@@ -178,9 +210,23 @@ class Requester {
      *
      * Every iterator call reports a new batch.
      */
-    /*package*/ <T> Iterator<T> asIterator(final String tailApiUrl, final Class<T> type) {
+    /*package*/ <T> Iterator<T> asIterator(String _tailApiUrl, final Class<T> type) {
         method("GET");
-        if (!args.isEmpty())    throw new IllegalStateException();
+
+        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>() {
             /**
@@ -263,13 +309,12 @@ class Requester {
 
 
     private HttpURLConnection setupConnection(URL url) throws IOException {
-        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
+        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 OAuth token is present, it'll be set in the URL, so need to set the Authorization header
-        if (root.encodedAuthorization!=null && root.oauthAccessToken == null)
-            uc.setRequestProperty("Authorization", "Basic " + root.encodedAuthorization);
+        if (root.encodedAuthorization!=null)
+            uc.setRequestProperty("Authorization", root.encodedAuthorization);
 
         try {
             uc.setRequestMethod(method);
@@ -341,4 +386,11 @@ class Requester {
             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,15 +1,30 @@
 package org.kohsuke;
 
-import junit.framework.TestCase;
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+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 org.junit.Assume;
+import org.junit.Before;
+import org.junit.Test;
+import org.kohsuke.github.GHBranch;
 import org.kohsuke.github.GHCommit;
 import org.kohsuke.github.GHCommit.File;
 import org.kohsuke.github.GHCommitComment;
+import org.kohsuke.github.GHCommitState;
 import org.kohsuke.github.GHCommitStatus;
 import org.kohsuke.github.GHEvent;
 import org.kohsuke.github.GHEventInfo;
 import org.kohsuke.github.GHEventPayload;
 import org.kohsuke.github.GHHook;
-import org.kohsuke.github.GHBranch;
 import org.kohsuke.github.GHIssue;
 import org.kohsuke.github.GHIssueComment;
 import org.kohsuke.github.GHIssueState;
@@ -28,6 +43,7 @@ import org.kohsuke.github.PagedIterable;
 import java.io.IOException;
 import java.net.URL;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.Map;
 import java.util.Set;
 import java.util.List;
@@ -35,63 +51,166 @@ import java.util.List;
 /**
  * Unit test for simple App.
  */
-public class AppTest extends TestCase {
+public class AppTest {
+
+    private GitHub gitHub;
+
+    @Before
+    public void setUp() throws Exception {
+        gitHub = GitHub.connect();
+    }
+
+    private String getTestRepositoryName() throws IOException {
+        return getUser().getLogin() + "/github-api-test";
+    }
+
+    @Test
     public void testRepoCRUD() throws Exception {
-        GitHub hub = GitHub.connect();
-        GHRepository r = hub.createRepository("github-api-test", "a test repository", "http://github-api.kohsuke.org/", true);
+        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("github-api-test2");
-        hub.getMyself().getRepository("github-api-test2").delete();
+        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.connect().isCredentialValid());
-        assertFalse(GitHub.connect("totally", "bogus").isCredentialValid());
+        assertTrue(gitHub.isCredentialValid());
+        GitHub connect = GitHub.connect("totally", "bogus");
+        assertFalse(connect.isCredentialValid());
     }
 
+    @Test
     public void testIssueWithNoComment() throws IOException {
-        GHRepository repository = GitHub.connect().getRepository("kohsuke/test");
+        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);
+        assertTrue(v.size() == 3);
     }
 
+    @Test
     public void testCreateIssue() throws IOException {
-        GHUser u = GitHub.connect().getUser("kohsuke");
-        GHRepository r = u.getRepository("test");
-        GHMilestone someMilestone = r.listMilestones(GHIssueState.CLOSED).iterator().next();
-        GHIssue o = r.createIssue("testing").body("this is body").assignee(u).label("bug").label("question").milestone(someMilestone).create();
-        System.out.println(o.getUrl());
+        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();
     }
 
-    public void testRateLimit() throws IOException {
-        System.out.println(GitHub.connect().getRateLimit());
+    @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.connect().getMyOrganizations();
+        Map<String, GHOrganization> org = gitHub.getMyOrganizations();
         assertFalse(org.keySet().contains(null));
         System.out.println(org);
     }
 
+    @Test
     public void testFetchPullRequest() throws Exception {
-        GitHub gh = GitHub.connect();
-        GHRepository r = gh.getOrganization("jenkinsci").getRepository("jenkins");
+        GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("jenkins");
         assertEquals("master",r.getMasterBranch());
         r.getPullRequest(1);
         r.getPullRequests(GHIssueState.OPEN);
     }
 
+    @Test
     public void testFetchPullRequestAsList() throws Exception {
-        GitHub gh = GitHub.connect();
-        GHRepository r = gh.getOrganization("symfony").getRepository("symfony-docs");
+        GHRepository r = gitHub.getRepository("kohsuke/github-api");
         assertEquals("master", r.getMasterBranch());
         PagedIterable<GHPullRequest> i = r.listPullRequests(GHIssueState.CLOSED);
         List<GHPullRequest> prs = i.asList();
@@ -99,59 +218,74 @@ public class AppTest extends TestCase {
         assertTrue(prs.size() > 0);
     }
 
+    @Test
     public void testRepoPermissions() throws Exception {
-        GitHub gh = GitHub.connect();
-        GHRepository r = gh.getOrganization("jenkinsci").getRepository("jenkins");
+        kohsuke();
+        GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("jenkins");
         assertTrue(r.hasPullAccess());
 
-        r = gh.getOrganization("github").getRepository("tire");
+        r = gitHub.getOrganization("github").getRepository("hub");
         assertFalse(r.hasAdminAccess());
     }
     
+    @Test
     public void testGetMyself() throws Exception {
-        GitHub hub = GitHub.connect();
-        GHMyself me = hub.getMyself();
-        System.out.println(me);
-        GHUser u = hub.getUser("kohsuke2");
-        System.out.println(u);
-        for (List<GHRepository> lst : me.iterateRepositories(100)) {
-            for (GHRepository r : lst) {
-                System.out.println(r.getPushedAt());
-            }
-        }
+        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 {
-        GitHub gh = GitHub.connect();
-        List<GHKey> keys = gh.getMyself().getPublicKeys();
-        System.out.println(keys);
+        List<GHKey> keys = gitHub.getMyself().getPublicKeys();
+        assertFalse(keys.isEmpty());
     }
 
-    public void tryOrgFork() throws Exception {
-        GitHub gh = GitHub.connect();
-        gh.getUser("kohsuke").getRepository("rubywm").forkTo(gh.getOrganization("jenkinsci"));
+    @Test
+    public void testOrgFork() throws Exception {
+        kohsuke();
+        getUser().getRepository("rubywm").forkTo(gitHub.getOrganization("jenkinsci"));
     }
 
-    public void tryGetTeamsForRepo() throws Exception {
-        GitHub gh = GitHub.connect();
-        Set<GHTeam> o = gh.getOrganization("jenkinsci").getRepository("rubywm").getTeams();
-        System.out.println(o);
+    @Test
+    public void testGetTeamsForRepo() throws Exception {
+        kohsuke();
+        assertEquals(1,gitHub.getOrganization("stapler").getRepository("stapler").getTeams().size());
     }
 
+    @Test
     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"));
     }
-    
+
+    @Test
     public void testMemberOrgs() throws Exception {
-        GitHub gitHub = GitHub.connect();
         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("jenkinsci").listTeams()) {
+            assertNotNull(t.getName());
+            sz++;
+        }
+        assertTrue(sz>1000);
+    }
+
+    public void testOrgTeamByName() throws Exception {
+        kohsuke();
+        GHTeam e = gitHub.getOrganization("jenkinsci").getTeamByName("Everyone");
+        assertNotNull(e);
+    }
+
+    @Test
     public void testCommit() throws Exception {
-        GitHub gitHub = GitHub.connect();
         GHCommit commit = gitHub.getUser("jenkinsci").getRepository("jenkins").getCommit("08c1c9970af4d609ae754fbe803e06186e3206f7");
         System.out.println(commit);
         assertEquals(1, commit.getParents().size());
@@ -160,29 +294,40 @@ public class AppTest extends TestCase {
         File f = commit.getFiles().get(0);
         assertEquals(48,f.getLinesChanged());
         assertEquals("modified",f.getStatus());
-        assertEquals("changelog.html",f.getFileName());
+        assertEquals("changelog.html", f.getFileName());
     }
 
+    @Test
     public void testListCommits() throws Exception {
-        GitHub gitHub = GitHub.connect();
         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());
+        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 {
-        GitHub gitHub = GitHub.connect();
         Map<String,GHBranch> b =
                 gitHub.getUser("jenkinsci").getRepository("jenkins").getBranches();
         System.out.println(b);
     }
 
+    @Test
     public void testCommitComment() throws Exception {
-        GitHub gitHub = GitHub.connect();
         GHRepository r = gitHub.getUser("jenkinsci").getRepository("jenkins");
         PagedIterable<GHCommitComment> comments = r.listCommitComments();
         List<GHCommitComment> batch = comments.iterator().nextPage();
@@ -192,8 +337,8 @@ public class AppTest extends TestCase {
         }
     }
 
+    @Test
     public void testCreateCommitComment() throws Exception {
-        GitHub gitHub = GitHub.connect();
         GHCommit commit = gitHub.getUser("kohsuke").getRepository("sandbox-ant").getCommit("8ae38db0ea5837313ab5f39d43a6f73de3bd9000");
         GHCommitComment c = commit.createComment("[testing](http://kohsuse.org/)");
         System.out.println(c);
@@ -202,8 +347,9 @@ public class AppTest extends TestCase {
         c.delete();
     }
 
+    @Test
     public void tryHook() throws Exception {
-        GitHub gitHub = GitHub.connect();
+        kohsuke();
         GHRepository r = gitHub.getMyself().getRepository("test2");
         GHHook hook = r.createWebHook(new URL("http://www.google.com/"));
         System.out.println(hook);
@@ -212,8 +358,8 @@ public class AppTest extends TestCase {
             h.delete();
     }
     
+    @Test
     public void testEventApi() throws Exception {
-        GitHub gitHub = GitHub.connect();
         for (GHEventInfo ev : gitHub.getEvents()) {
             System.out.println(ev);
             if (ev.getType()==GHEvent.PULL_REQUEST) {
@@ -224,11 +370,11 @@ public class AppTest extends TestCase {
         }
     }
 
+    @Test
     public void testApp() throws IOException {
-        GitHub gitHub = GitHub.connect();
         System.out.println(gitHub.getMyself().getEmails());
 
-//        GHRepository r = gitHub.connect().getOrganization("jenkinsci").createRepository("kktest4", "Kohsuke's test", "http://kohsuke.org/", "Everyone", true);
+//        GHRepository r = gitHub.getOrganization("jenkinsci").createRepository("kktest4", "Kohsuke's test", "http://kohsuke.org/", "Everyone", true);
 //        r.fork();
 
 //        tryDisablingIssueTrackers(gitHub);
@@ -255,7 +401,7 @@ public class AppTest extends TestCase {
 //        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);
+//        GHRepository r = gitHub.getOrganization("HudsonLabs").createRepository("auto-test", "some description", "http://kohsuke.org/", "Plugin Developers", true);
 
 //        r.
 //        GitHub hub = GitHub.connectAnonymously();
@@ -313,8 +459,9 @@ public class AppTest extends TestCase {
         System.out.println(hooks);
     }
 
+    @Test
     public void testOrgRepositories() throws IOException {
-        GitHub gitHub = GitHub.connect();
+        kohsuke();
         GHOrganization j = gitHub.getOrganization("jenkinsci");
         long start = System.currentTimeMillis();
         Map<String, GHRepository> repos = j.getRepositories();
@@ -322,8 +469,9 @@ public class AppTest extends TestCase {
         System.out.printf("%d repositories in %dms\n",repos.size(),end-start);
     }
     
+    @Test
     public void testOrganization() throws IOException {
-        GitHub gitHub = GitHub.connect();
+        kohsuke();
         GHOrganization j = gitHub.getOrganization("jenkinsci");
         GHTeam t = j.getTeams().get("Core Developers");
 
@@ -332,24 +480,52 @@ public class AppTest extends TestCase {
 //        t.add(labs.getRepository("xyz"));
     }
 
+    @Test
     public void testCommitStatus() throws Exception {
-        GitHub gitHub = GitHub.connect();
-        GHRepository r = gitHub.getUser("kohsuke").getRepository("test");
-        GHCommitStatus state;
-//        state = r.createCommitStatus("edacdd76b06c5f3f0697a22ca75803169f25f296", GHCommitState.FAILURE, "http://jenkins-ci.org/", "oops!");
+        GHRepository r = gitHub.getRepository("kohsuke/github-api");
 
-        List<GHCommitStatus> lst = r.listCommitStatuses("edacdd76b06c5f3f0697a22ca75803169f25f296").asList();
+        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("oops!",state.getDescription());
-        assertEquals("http://jenkins-ci.org/",state.getTargetUrl());
+        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 {
-        GitHub gitHub = GitHub.connect();
         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));
+    }
+
+    private void kohsuke() {
+        Assume.assumeTrue(getUser().getLogin().equals("kohsuke"));
+    }
 }

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

@@ -0,0 +1,147 @@
+package org.kohsuke;
+
+import junit.framework.TestCase;
+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.kohsuke.github.GHAsset;
+import org.kohsuke.github.GHIssue;
+import org.kohsuke.github.GHMilestone;
+import org.kohsuke.github.GHMyself;
+import org.kohsuke.github.GHRelease;
+import org.kohsuke.github.GHRepository;
+import org.kohsuke.github.GitHub;
+
+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 TestCase {
+    private GitHub gitHub;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        gitHub = GitHub.connect();
+    }
+
+    public void testCreateRepository() throws IOException, GitAPIException, InterruptedException {
+        GHMyself myself = gitHub.getMyself();
+        GHRepository repository = myself.getRepository("github-api-test");
+        if (repository != null) {
+            repository.delete();
+            Thread.sleep(1000);
+        }
+        repository = gitHub.createRepository("github-api-test",
+                "a test repository used to test kohsuke's github-api", "http://github-api.kohsuke.org/", true);
+
+        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.gitHttpTransportUrl())
+                    .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/GHContentIntegrationTest.java

@@ -0,0 +1,67 @@
+package org.kohsuke.github;
+
+import junit.framework.TestCase;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Integration test for {@link GHContent}.
+ */
+public class GHContentIntegrationTest extends TestCase {
+
+    private GitHub gitHub;
+    private GHRepository repo;
+    private String createdFilename;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+
+        gitHub = GitHub.connect();
+        repo = gitHub.getRepository("acollign/github-api-test").fork();
+        createdFilename = UUID.randomUUID().toString();
+    }
+
+    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());
+    }
+
+    public void testGetEmptyFileContent() throws Exception {
+        GHContent content = repo.getFileContent("ghcontent-ro/an-empty-file");
+
+        assertTrue(content.isFile());
+        assertEquals("", content.getContent());
+    }
+
+    public void testGetDirectoryContent() throws Exception {
+        List<GHContent> entries = repo.getDirectoryContent("ghcontent-ro/a-dir-with-3-entries");
+
+        assertTrue(entries.size() == 3);
+    }
+
+    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/GitHubTest.java

@@ -8,17 +8,17 @@ import junit.framework.TestCase;
 public class GitHubTest extends TestCase {
 
     public void testGitHubServerWithHttp() throws Exception {
-        GitHub hub = GitHub.connectToEnterprise("http://enterprise.kohsuke.org/api/v3", "kohsuke", "token");
+        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", "kohsuke", "token");
+        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.connect("kohsuke", "token", "password");
+        GitHub hub = GitHub.connectUsingPassword("kohsuke", "bogus");
         assertEquals("https://api.github.com/test", hub.getApiURL("/test").toString());
     }
 }