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

Commit's short info model

.gitignore

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

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.30</version>
+  <version>1.44</version>
   <name>GitHub API for Java</name>
   <url>http://github-api.kohsuke.org/</url>
   <description>GitHub API for Java</description>
@@ -25,6 +25,10 @@
     </site>
   </distributionManagement>
 
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
   <build>
     <plugins>
       <plugin>
@@ -44,16 +48,14 @@
 
   <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>
@@ -64,7 +66,7 @@
     <dependency>
       <groupId>org.codehaus.jackson</groupId>
       <artifactId>jackson-mapper-asl</artifactId>
-      <version>1.5.0</version>
+      <version>1.9.9</version>
     </dependency>
     <dependency>
       <groupId>commons-io</groupId>
@@ -85,6 +87,13 @@
     </dependency>
   </dependencies>
 
+  <repositories>
+    <repository>
+      <id>repo.jenkins-ci.org</id>
+      <url>http://repo.jenkins-ci.org/public/</url>
+    </repository>
+  </repositories>
+
   <reporting>
     <plugins>
       <plugin>

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

@@ -5,6 +5,7 @@ import java.net.URL;
 import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Date;
 import java.util.List;
 
 /**
@@ -16,6 +17,55 @@ 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;
+
+    	public GHAuthor getAuthor() {
+    		return author;
+    	}
+
+		public GHAuthor getCommitter() {
+			return committer;
+		}
+
+        /**
+         * Commit message.
+         */
+		public String getMessage() {
+			return message;
+		}
+
+		public int getCommentCount() {
+			return comment_count;
+		}
+    }
+    
+    public static class GHAuthor {
+    	private String name,email,date;
+
+    	public String getName() {
+    		return name;
+    	}
+
+    	public String getEmail() {
+    		return email;
+    	}
+
+        public Date getDate() {
+            return GitHub.parseDate(date);
+        }
+    }
 
     public static class Stats {
         int total,additions,deletions;
@@ -110,8 +160,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() {
@@ -203,7 +259,7 @@ public class GHCommit {
     public PagedIterable<GHCommitComment> listComments() {
         return new PagedIterable<GHCommitComment>() {
             public PagedIterator<GHCommitComment> iterator() {
-                return new PagedIterator<GHCommitComment>(owner.root.retrievePaged(String.format("/repos/%s/%s/commits/%s/comments",owner.getOwnerName(),owner.getName(),sha),GHCommitComment[].class,false)) {
+                return new PagedIterator<GHCommitComment>(owner.root.retrieve().asIterator(String.format("/repos/%s/%s/commits/%s/comments", owner.getOwnerName(), owner.getName(), sha), GHCommitComment[].class)) {
                     @Override
                     protected void wrapUp(GHCommitComment[] page) {
                         for (GHCommitComment c : page)
@@ -220,12 +276,11 @@ public class GHCommit {
      * I'm not sure how path/line/position parameters interact with each other.
      */
     public GHCommitComment createComment(String body, String path, Integer line, Integer position) throws IOException {
-        GHCommitComment r = new Poster(owner.root)
+        GHCommitComment r = new Requester(owner.root)
                 .with("body",body)
                 .with("path",path)
                 .with("line",line)
                 .with("position",position)
-                .withCredential()
                 .to(String.format("/repos/%s/%s/commits/%s/comments",owner.getOwnerName(),owner.getName(),sha),GHCommitComment.class);
         return r.wrap(owner);
     }
@@ -234,6 +289,20 @@ public class GHCommit {
         return createComment(body,null,null,null);
     }
 
+    /**
+     * Gets the status of this commit, newer ones first.
+     */
+    public PagedIterable<GHCommitStatus> listStatuses() throws IOException {
+        return owner.listCommitStatuses(sha);
+    }
+
+    /**
+     * Gets the last status of this commit, which is what gets shown in the UI.
+     */
+    public GHCommitStatus getLastStatus() throws IOException {
+        return owner.getLastCommitStatus(sha);
+    }
+
     GHCommit wrapUp(GHRepository owner) {
         this.owner = owner;
         return this;

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

@@ -97,10 +97,9 @@ public class GHCommitComment {
      * Updates the body of the commit message.
      */
     public void update(String body) throws IOException {
-        GHCommitComment r = new Poster(owner.root)
-                .with("body",body)
-                .withCredential()
-                .to(getApiTail(),GHCommitComment.class,"PATCH");
+        GHCommitComment r = new Requester(owner.root)
+                .with("body", body)
+                .method("PATCH").to(getApiTail(), GHCommitComment.class);
         this.body = body;
     }
 
@@ -108,7 +107,7 @@ public class GHCommitComment {
      * Deletes this comment.
      */
     public void delete() throws IOException {
-        new Poster(owner.root).withCredential().to(getApiTail(),null,"DELETE");
+        new Requester(owner.root).method("DELETE").to(getApiTail());
     }
 
     private String getApiTail() {

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

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

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

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

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

@@ -0,0 +1,156 @@
+package org.kohsuke.github;
+
+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;
+        }
+
+        public User getAuthor() {
+            return author;
+        }
+
+        public User 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;
+        }
+    }
+
+    public static class User {
+        private String name, email, date;
+
+        public String getName() {
+            return name;
+        }
+
+        public String getEmail() {
+            return email;
+        }
+
+        public Date getDate() {
+            return GitHub.parseDate(date);
+        }
+    }
+
+    public static enum Status {
+        behind, ahead, identical;
+    }
+}

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

@@ -18,10 +18,16 @@ public abstract class GHEventPayload {
         this.root = root;
     }
 
+    /**
+     * A pull request status has changed.
+     *
+     * @see http://developer.github.com/v3/activity/events/types/#pullrequestevent
+     */
     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 +42,67 @@ 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 (repository!=null) {
+                repository.wrap(root);
+                pull_request.wrap(repository);
+            } else {
+                pull_request.wrapUp(root);
+            }
         }
     }
 
+    /**
+     * A comment was added to an issue
+     *
+     * @see http://developer.github.com/v3/activity/events/types/#issuecommentevent
+     */
+    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);
+        }
+    }
 }

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

@@ -54,7 +54,6 @@ public final class GHHook {
      * Deletes this hook.
      */
     public void delete() throws IOException {
-        new Poster(repository.root).withCredential()
-                .to(String.format("/repos/%s/%s/hooks/%d",repository.getOwnerName(),repository.getName(),id),null,"DELETE");
+        new Requester(repository.root).method("DELETE").to(String.format("/repos/%s/%s/hooks/%d", repository.getOwnerName(), repository.getName(), id));
     }
 }

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

@@ -26,11 +26,11 @@ package org.kohsuke.github;
 
 import java.io.IOException;
 import java.net.URL;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.List;
+import java.util.Locale;
 
 /**
  * Represents an issue on GitHub.
@@ -41,15 +41,30 @@ import java.util.List;
 public class GHIssue {
     GitHub root;
     GHRepository owner;
-
-    private String gravatar_id,body,title,state,created_at,updated_at,html_url;
-    private List<String> labels;
-    private int number,votes,comments;
-    private int position;
+	
+	// API v3
+    protected GHUser assignee;
+    protected String state;
+    protected int number;
+    protected String closed_at;
+    protected int comments;
+    protected String body;
+    protected List<String> labels;
+    protected GHUser user;
+    protected String title, created_at, html_url;
+    protected GHIssue.PullRequest pull_request;
+    protected GHMilestone milestone;
+	protected String url, updated_at;
+    protected int id;
+    protected GHUser closed_by;
 
     /*package*/ GHIssue wrap(GHRepository owner) {
         this.owner = owner;
         this.root = owner.root;
+		if(milestone != null) milestone.wrap(owner);
+		if(assignee != null) assignee.wrapUp(root);
+		if(user != null) user.wrapUp(root);
+		if(closed_by != null) closed_by.wrapUp(root);
         return this;
     }
 
@@ -93,10 +108,13 @@ public class GHIssue {
     }
 
     public GHIssueState getState() {
-        return Enum.valueOf(GHIssueState.class, state);
+        return Enum.valueOf(GHIssueState.class, state.toUpperCase(Locale.ENGLISH));
     }
 
     public Collection<String> getLabels() {
+        if(labels == null){
+            return Collections.EMPTY_LIST;
+        }
         return Collections.unmodifiableList(labels);
     }
 
@@ -108,16 +126,23 @@ public class GHIssue {
         return GitHub.parseDate(updated_at);
     }
 
+    public Date getClosedAt() {
+        return GitHub.parseDate(closed_at);
+    }
+
+	public URL getApiURL(){
+        return GitHub.parseURL(url);
+	}
+
     /**
      * Updates the issue by adding a comment.
      */
     public void comment(String message) throws IOException {
-        new Poster(root).withCredential().with("body",message).to(getApiRoute()+"/comments",null,"POST");
+        new Requester(root).with("body",message).to(getIssuesApiRoute() + "/comments");
     }
 
     private void edit(String key, Object value) throws IOException {
-        new Poster(root).withCredential()._with(key, value)
-                .to(getApiRoute(),null,"PATCH");
+        new Requester(root)._with(key, value).method("PATCH").to(getApiRoute());
     }
 
     /**
@@ -152,15 +177,81 @@ public class GHIssue {
 
     /**
      * Obtains all the comments associated with this issue.
+	 * 
+	 * @see #listComments() 
      */
-    public List<GHIssueComment> getComments() throws IOException {
-        GHIssueComment[] r = root.retrieve(getApiRoute() + "/comments", GHIssueComment[].class);
-        for (GHIssueComment c : r)
-            c.wrapUp(this);
-        return Arrays.asList(r);
+	public List<GHIssueComment> getComments() throws IOException {
+		return listComments().asList();
+	}
+	
+	/**
+	 * Obtains all the comments associated with this issue.
+	 */
+    public PagedIterable<GHIssueComment> listComments() throws IOException {
+        return new PagedIterable<GHIssueComment>() {
+            public PagedIterator<GHIssueComment> iterator() {
+                return new PagedIterator<GHIssueComment>(root.retrieve().asIterator(getIssuesApiRoute() + "/comments", GHIssueComment[].class)) {
+                    protected void wrapUp(GHIssueComment[] page) {
+                        for (GHIssueComment c : page)
+                            c.wrapUp(GHIssue.this);
+                    }
+                };
+            }
+        };
     }
 
-    private String getApiRoute() {
+    protected String getApiRoute() {
+        return getIssuesApiRoute();
+    }
+
+    private String getIssuesApiRoute() {
         return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/issues/"+number;
     }
-}
+
+	public GHUser getAssignee() {
+		return assignee;
+	}
+	
+    /**
+     * User who submitted the issue.
+     */
+	public GHUser getUser() {
+        return user;
+	}
+	
+	public GHUser getClosedBy() {
+		if(!"closed".equals(state)) return null;
+		if(closed_by != null) return closed_by;
+		
+		//TODO closed_by = owner.getIssue(number).getClosed_by();
+		return closed_by;
+	}
+	
+	public int getCommentsCount(){
+		return comments;
+	}
+
+	public PullRequest getPullRequest() {
+		return pull_request;
+	}
+
+	public GHMilestone getMilestone() {
+		return milestone;
+	}
+
+	public static class PullRequest{
+		private String diff_url, patch_url, html_url;
+		
+		public URL getDiffUrl() {
+			return GitHub.parseURL(diff_url);
+		}
+		
+		public URL getPatchUrl() {
+			return GitHub.parseURL(patch_url);
+		}
+		
+		public URL getUrl() {
+			return GitHub.parseURL(html_url);
+		}
+	}
+}

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

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

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

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

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

@@ -3,7 +3,12 @@ package org.kohsuke.github;
 import java.io.IOException;
 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.
@@ -22,7 +27,7 @@ public class GHMyself extends GHUser {
      *      Always non-null.
      */
     public List<String> getEmails() throws IOException {
-        String[] addresses = root.retrieveWithAuth("/user/emails", String[].class);
+        String[] addresses = root.retrieve().to("/user/emails", String[].class);
         return Collections.unmodifiableList(Arrays.asList(addresses));
     }
 
@@ -33,11 +38,54 @@ public class GHMyself extends GHUser {
      *      Always non-null.
      */
     public List<GHKey> getPublicKeys() throws IOException {
-        return Collections.unmodifiableList(Arrays.asList(root.retrieveWithAuth("/user/keys", GHKey[].class)));
+        return Collections.unmodifiableList(Arrays.asList(root.retrieve().to("/user/keys", GHKey[].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 Poster(root,ApiVersion.V3).withCredential().to("/user/emails");
+////        new Requester(root,ApiVersion.V3).withCredential().to("/user/emails");
 //        root.retrieveWithAuth3()
 //    }
 }

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

@@ -1,9 +1,5 @@
 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;
@@ -33,7 +29,7 @@ public class GHOrganization extends GHPerson {
 
     public GHRepository createRepository(String name, String description, String homepage, GHTeam team, boolean isPublic) throws IOException {
         // such API doesn't exist, so fall back to HTML scraping
-        return new Poster(root).withCredential()
+        return new Requester(root)
                 .with("name", name).with("description", description).with("homepage", homepage)
                 .with("public", isPublic).with("team_id",team.getId()).to("/orgs/"+login+"/repos", GHRepository.class).wrap(root);
     }
@@ -42,7 +38,7 @@ public class GHOrganization extends GHPerson {
      * Teams by their names.
      */
     public Map<String,GHTeam> getTeams() throws IOException {
-        GHTeam[] teams = root.retrieveWithAuth("/orgs/" + login + "/teams", GHTeam[].class);
+        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));
@@ -50,11 +46,35 @@ public class GHOrganization extends GHPerson {
         return r;
     }
 
+    /**
+     * 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;
+        }
+    }
+
+    /**
+     * 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.
      */
     public void publicize(GHUser u) throws IOException {
-        root.retrieveWithAuth("/orgs/" + login + "/public_members/" + u.getLogin(), null, "PUT");
+        root.retrieve().method("PUT").to("/orgs/" + login + "/public_members/" + u.getLogin(), null);
     }
 
     /**
@@ -64,7 +84,7 @@ public class GHOrganization extends GHPerson {
         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.retrieveWithAuth("/orgs/" + login + "/members", GHUser[].class);
+            final GHUser[] shallow = root.retrieve().to("/orgs/" + login + "/members", GHUser[].class);
 
             @Override
             public GHUser get(int index) {
@@ -86,7 +106,7 @@ public class GHOrganization extends GHPerson {
      * Conceals the membership.
      */
     public void conceal(GHUser u) throws IOException {
-        root.retrieveWithAuth("/orgs/" + login + "/public_members/" + u.getLogin(), null, "DELETE");
+        root.retrieve().method("DELETE").to("/orgs/" + login + "/public_members/" + u.getLogin(), null);
     }
 
     public enum Permission { ADMIN, PUSH, PULL }
@@ -95,13 +115,13 @@ public class GHOrganization extends GHPerson {
      * Creates a new team and assigns the repositories.
      */
     public GHTeam createTeam(String name, Permission p, Collection<GHRepository> repositories) throws IOException {
-        Poster post = new Poster(root).withCredential().with("name", name).with("permission", p.name().toLowerCase());
+        Requester post = new Requester(root).with("name", name).with("permission", p.name().toLowerCase());
         List<String> repo_names = new ArrayList<String>();
         for (GHRepository r : repositories) {
             repo_names.add(r.getName());
         }
         post.with("repo_names",repo_names);
-        return post.to("/orgs/"+login+"/teams",GHTeam.class,"POST").wrapUp(this);
+        return post.method("POST").to("/orgs/" + login + "/teams", GHTeam.class).wrapUp(this);
     }
 
     public GHTeam createTeam(String name, Permission p, GHRepository... repositories) throws IOException {
@@ -110,15 +130,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;
     }

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

@@ -17,13 +17,13 @@ import java.util.TreeMap;
 public abstract class GHPerson {
     /*package almost final*/ GitHub root;
 
-    // common
-    protected String login,location,blog,email,name,created_at,company;
+    // core data fields that exist even for "small" user data (such as the user info in pull request)
+    protected String login, avatar_url, url, gravatar_id;
     protected int id;
-    protected String gravatar_id; // appears in V3 as well but presumably subsumed by avatar_url?
 
-    // V3
-    protected String avatar_url,html_url;
+    // other fields (that only show up in full data)
+    protected String location,blog,email,name,created_at,company;
+    protected String html_url;
     protected int followers,following,public_repos,public_gists;
 
     /*package*/ GHPerson wrapUp(GitHub root) {
@@ -31,6 +31,17 @@ public abstract class GHPerson {
         return this;
     }
 
+    /**
+     * Fully populate the data by retrieving missing data.
+     *
+     * Depending on the original API call where this object is created, it may not contain everything.
+     */
+    protected void populate() throws IOException {
+        if (created_at!=null)    return; // already populated
+
+        root.retrieve().to(url, this);
+    }
+
     /**
      * Gets the repositories this user owns.
      */
@@ -43,6 +54,25 @@ public abstract class GHPerson {
         return Collections.unmodifiableMap(repositories);
     }
 
+    /**
+     * Lists up all the repositories.
+     *
+     * Unlike {@link #getRepositories()}, this does not wait until all the repositories are returned.
+     */
+    public PagedIterable<GHRepository> listRepositories() {
+        return new PagedIterable<GHRepository>() {
+            public PagedIterator<GHRepository> iterator() {
+                return new PagedIterator<GHRepository>(root.retrieve().asIterator("/users/" + login + "/repos", GHRepository[].class)) {
+                    @Override
+                    protected void wrapUp(GHRepository[] page) {
+                        for (GHRepository c : page)
+                            c.wrap(root);
+                    }
+                };
+            }
+        };
+    }
+
     /**
      * Loads repository list in a pagenated fashion.
      * 
@@ -52,11 +82,14 @@ 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>>() {
             public Iterator<List<GHRepository>> iterator() {
-                final Iterator<GHRepository[]> pager = root.retrievePaged("/users/" + login + "/repos?per_page="+pageSize,GHRepository[].class,false);
+                final Iterator<GHRepository[]> pager = root.retrieve().asIterator("/users/" + login + "/repos?per_page="+pageSize,GHRepository[].class);
 
                 return new Iterator<List<GHRepository>>() {
                     public boolean hasNext() {
@@ -85,7 +118,7 @@ public abstract class GHPerson {
      */
     public GHRepository getRepository(String name) throws IOException {
         try {
-            return root.retrieveWithAuth("/repos/" + login + '/' + name, GHRepository.class).wrap(root);
+            return root.retrieve().to("/repos/" + login + '/' + name, GHRepository.class).wrap(root);
         } catch (FileNotFoundException e) {
             return null;
         }
@@ -123,51 +156,60 @@ public abstract class GHPerson {
     /**
      * Gets the human-readable name of the user, like "Kohsuke Kawaguchi"
      */
-    public String getName() {
+    public String getName() throws IOException {
+        populate();
         return name;
     }
 
     /**
      * Gets the company name of this user, like "Sun Microsystems, Inc."
      */
-    public String getCompany() {
+    public String getCompany() throws IOException {
+        populate();
         return company;
     }
 
     /**
      * Gets the location of this user, like "Santa Clara, California"
      */
-    public String getLocation() {
+    public String getLocation() throws IOException {
+        populate();
         return location;
     }
 
-    public String getCreatedAt() {
+    public String getCreatedAt() throws IOException {
+        populate();
         return created_at;
     }
 
     /**
      * Gets the blog URL of this user.
      */
-    public String getBlog() {
+    public String getBlog() throws IOException {
+        populate();
         return blog;
     }
 
     /**
      * Gets the e-mail address of the user.
      */
-    public String getEmail() {
+    public String getEmail() throws IOException {
+        populate();
         return email;
     }
 
-    public int getPublicGistCount() {
+    public int getPublicGistCount() throws IOException {
+        populate();
         return public_gists;
     }
 
-    public int getPublicRepoCount() {
+    public int getPublicRepoCount() throws IOException {
+        populate();
         return public_repos;
     }
 
-    public int getFollowingCount() {
+    public int getFollowingCount() throws IOException {
+        populate();
         return following;
     }
 
@@ -178,7 +220,8 @@ public abstract class GHPerson {
         return id;
     }
 
-    public int getFollowersCount() {
+    public int getFollowersCount() throws IOException {
+        populate();
         return followers;
     }
 

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

@@ -23,7 +23,9 @@
  */
 package org.kohsuke.github;
 
+import java.io.IOException;
 import java.net.URL;
+import java.util.Collection;
 import java.util.Date;
 
 /**
@@ -33,11 +35,39 @@ import java.util.Date;
  */
 @SuppressWarnings({"UnusedDeclaration"})
 public class GHPullRequest extends GHIssue {
-    private String closed_at, patch_url, issue_updated_at;
-    private GHUser issue_user, user;
-    // labels??
-    private GHCommitPointer base, head;
-    private String mergeable, diff_url;
+	
+	private String patch_url, diff_url, issue_url;
+	private GHCommitPointer base;
+	private String merged_at;
+	private GHCommitPointer head;
+
+    // details that are only available when obtained from ID
+    private GHUser merged_by;
+   	private int review_comments, additions;
+   	private boolean merged;
+   	private Boolean mergeable;
+   	private int deletions;
+   	private String mergeable_state;
+   	private int changed_files;
+
+
+	GHPullRequest wrapUp(GHRepository owner) {
+		this.wrap(owner);
+        return wrapUp(owner.root);
+    }
+	
+    GHPullRequest wrapUp(GitHub root) {
+        if (owner!=null)    owner.wrap(root);
+        if (base!=null)     base.wrapUp(root);
+        if (head!=null)     head.wrapUp(root);
+        if (merged_by != null) merged_by.wrapUp(root);
+        return this;
+    }
+
+    @Override
+    protected String getApiRoute() {
+        return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/pulls/"+number;
+    }
 
     /**
      * The URL of the patch file.
@@ -46,12 +76,13 @@ public class GHPullRequest extends GHIssue {
     public URL getPatchUrl() {
         return GitHub.parseURL(patch_url);
     }
-
-    /**
-     * User who submitted a pull request.
+	
+	/**
+     * The URL of the patch file.
+     * like https://github.com/jenkinsci/jenkins/pull/100.patch
      */
-    public GHUser getUser() {
-        return user;
+    public URL getIssueUrl() {
+        return GitHub.parseURL(issue_url);
     }
 
     /**
@@ -69,16 +100,9 @@ public class GHPullRequest extends GHIssue {
         return head;
     }
 
+	@Deprecated
     public Date getIssueUpdatedAt() {
-        return GitHub.parseDate(issue_updated_at);
-    }
-
-    /**
-     * The HTML page of this pull request,
-     * like https://github.com/jenkinsci/jenkins/pull/100
-     */
-    public URL getUrl() {
-        return super.getUrl();
+        return super.getUpdatedAt();
     }
 
     /**
@@ -89,22 +113,77 @@ public class GHPullRequest extends GHIssue {
         return GitHub.parseURL(diff_url);
     }
 
-    public Date getClosedAt() {
-        return GitHub.parseDate(closed_at);
+    public Date getMergedAt() {
+        return GitHub.parseDate(merged_at);
     }
 
-    GHPullRequest wrapUp(GHRepository owner) {
-        this.owner = owner;
-        return wrapUp(owner.root);
-    }
+	@Override
+	public Collection<String> getLabels() {
+		return super.getLabels();
+	}
 
-    GHPullRequest wrapUp(GitHub root) {
-        this.root = root;
-        if (owner!=null)    owner.wrap(root);
-        if (issue_user!=null)   issue_user.root=root;
-        if (user!=null)     user.root=root;
-        if (base!=null)     base.wrapUp(root);
-        if (head!=null)     head.wrapUp(root);
-        return this;
+	@Override
+	public GHUser getClosedBy() {
+		return null;
+	}
+
+	@Override
+	public PullRequest getPullRequest() {
+		return null;
+	}
+
+//
+// details that are only available via get with ID
+//
+//
+    public GHUser getMergedBy() throws IOException {
+        populate();
+   		return merged_by;
+   	}
+
+   	public int getReviewComments() throws IOException {
+        populate();
+   		return review_comments;
+   	}
+
+   	public int getAdditions() throws IOException {
+        populate();
+   		return additions;
+   	}
+
+    public boolean isMerged() throws IOException {
+        populate();
+   		return merged;
+   	}
+
+   	public Boolean getMergeable() throws IOException {
+        populate();
+   		return mergeable;
+   	}
+
+   	public int getDeletions() throws IOException {
+        populate();
+   		return deletions;
+   	}
+
+   	public String getMergeableState() throws IOException {
+        populate();
+   		return mergeable_state;
+   	}
+
+   	public int getChangedFiles() throws IOException {
+        populate();
+   		return changed_files;
+   	}
+
+    /**
+     * Fully populate the data by retrieving missing data.
+     *
+     * Depending on the original API call where this object is created, it may not contain everything.
+     */
+    private void populate() throws IOException {
+        if (merged_by!=null)    return; // already populated
+
+        root.retrieve().to(url, this);
     }
 }

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/GHRepository.java

@@ -23,12 +23,6 @@
  */
 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.infradna.tool.bridge_method_injector.WithBridgeMethods;
 
 import java.io.IOException;
@@ -140,8 +134,16 @@ public class GHRepository {
         return root.getUser(owner.login);   // because 'owner' isn't fully populated
     }
 
+    public GHIssue getIssue(int id) throws IOException {
+        return root.retrieve().to("/repos/" + owner.login + "/" + name + "/issues/" + id, GHIssue.class).wrap(this);
+    }
+
+    public GHIssueBuilder createIssue(String title) {
+        return new GHIssueBuilder(this,title);
+    }
+
     public List<GHIssue> getIssues(GHIssueState state) throws IOException {
-       return Arrays.asList(GHIssue.wrap(root.retrieve("/repos/" + owner.login + "/" + name + "/issues?state=" + state.toString().toLowerCase(), GHIssue[].class), this));
+        return Arrays.asList(GHIssue.wrap(root.retrieve().to("/repos/" + owner.login + "/" + name + "/issues?state=" + state.toString().toLowerCase(), GHIssue[].class), this));
     }
 
     protected String getOwnerName() {
@@ -213,7 +215,7 @@ public class GHRepository {
      */
     @WithBridgeMethods(Set.class)
     public GHPersonSet<GHUser> getCollaborators() throws IOException {
-        return new GHPersonSet<GHUser>(GHUser.wrap(root.retrieve("/repos/" + owner.login + "/" + name + "/collaborators", GHUser[].class),root));
+        return new GHPersonSet<GHUser>(GHUser.wrap(root.retrieve().to("/repos/" + owner.login + "/" + name + "/collaborators", GHUser[].class),root));
     }
 
     /**
@@ -222,7 +224,7 @@ public class GHRepository {
      */
     public Set<String> getCollaboratorNames() throws IOException {
         Set<String> r = new HashSet<String>();
-        for (GHUser u : GHUser.wrap(root.retrieve("/repos/" + owner.login + "/" + name + "/collaborators", GHUser[].class),root))
+        for (GHUser u : GHUser.wrap(root.retrieve().to("/repos/" + owner.login + "/" + name + "/collaborators", GHUser[].class),root))
             r.add(u.login);
         return r;
     }
@@ -231,7 +233,7 @@ public class GHRepository {
      * If this repository belongs to an organization, return a set of teams.
      */
     public Set<GHTeam> getTeams() throws IOException {
-        return Collections.unmodifiableSet(new HashSet<GHTeam>(Arrays.asList(GHTeam.wrapUp(root.retrieveWithAuth("/repos/" + owner.login + "/" + name + "/teams", GHTeam[].class), root.getOrganization(owner.login)))));
+        return Collections.unmodifiableSet(new HashSet<GHTeam>(Arrays.asList(GHTeam.wrapUp(root.retrieve().to("/repos/" + owner.login + "/" + name + "/teams", GHTeam[].class), root.getOrganization(owner.login)))));
     }
 
     public void addCollaborators(GHUser... users) throws IOException {
@@ -253,28 +255,22 @@ public class GHRepository {
     private void modifyCollaborators(Collection<GHUser> users, String method) throws IOException {
         verifyMine();
         for (GHUser user : users) {
-            new Poster(root).withCredential().to("/repos/"+owner.login+"/"+name+"/collaborators/"+user.getLogin(),null,method);
+            new Requester(root).method(method).to("/repos/" + owner.login + "/" + name + "/collaborators/" + user.getLogin());
         }
     }
 
     public void setEmailServiceHook(String address) throws IOException {
-        WebClient wc = root.createWebClient();
-        HtmlPage pg = (HtmlPage)wc.getPage(getUrl()+"/admin");
-        HtmlInput email = (HtmlInput)pg.getElementById("email_address");
-        email.setValueAttribute(address);
-        HtmlCheckBoxInput active = (HtmlCheckBoxInput)pg.getElementById("email[active]");
-        active.setChecked(true);
-
-        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 {
-        Poster poster = new Poster(root).withCredential();
+        Requester requester = new Requester(root);
         if (!key.equals("name"))
-            poster.with("name", name);   // even when we don't change the name, we need to send it in
-        poster.with(key, value)
-                .to("/repos/" + owner.login + "/" + name, null, "PATCH");
+            requester.with("name", name);   // even when we don't change the name, we need to send it in
+        requester.with(key, value).method("PATCH").to("/repos/" + owner.login + "/" + name);
     }
 
     /**
@@ -314,7 +310,7 @@ public class GHRepository {
      * Deletes this repository.
      */
     public void delete() throws IOException {
-        new Poster(root).withCredential().to("/repos/" + owner.login +"/"+name, null, "DELETE");
+        new Requester(root).method("DELETE").to("/repos/" + owner.login + "/" + name);
     }
 
     /**
@@ -324,7 +320,7 @@ public class GHRepository {
      *      Newly forked repository that belong to you.
      */
     public GHRepository fork() throws IOException {
-        return new Poster(root).withCredential().to("/repos/" + owner.login + "/" + name + "/forks", GHRepository.class, "POST").wrap(root);
+        return new Requester(root).method("POST").to("/repos/" + owner.login + "/" + name + "/forks", GHRepository.class).wrap(root);
     }
 
     /**
@@ -334,7 +330,7 @@ public class GHRepository {
      *      Newly forked repository that belong to you.
      */
     public GHRepository forkTo(GHOrganization org) throws IOException {
-        new Poster(root).withCredential().to(String.format("/repos/%s/%s/forks?org=%s",owner.login,name,org.getLogin()));
+        new Requester(root).to(String.format("/repos/%s/%s/forks?org=%s", owner.login, name, org.getLogin()));
 
         // this API is asynchronous. we need to wait for a bit
         for (int i=0; i<10; i++) {
@@ -353,7 +349,7 @@ public class GHRepository {
      * Retrieves a specified pull request.
      */
     public GHPullRequest getPullRequest(int i) throws IOException {
-        return root.retrieveWithAuth("/repos/" + owner.login + '/' + name + "/pulls/" + i, GHPullRequest.class).wrapUp(this);
+        return root.retrieve().to("/repos/" + owner.login + '/' + name + "/pulls/" + i, GHPullRequest.class).wrapUp(this);
     }
 
     /**
@@ -371,7 +367,7 @@ public class GHRepository {
     public PagedIterable<GHPullRequest> listPullRequests(final GHIssueState state) {
         return new PagedIterable<GHPullRequest>() {
             public PagedIterator<GHPullRequest> iterator() {
-                return new PagedIterator<GHPullRequest>(root.retrievePaged(String.format("/repos/%s/%s/pulls?state=%s", owner.login,name,state.name().toLowerCase(Locale.ENGLISH)), GHPullRequest[].class, false)) {
+                return new PagedIterator<GHPullRequest>(root.retrieve().asIterator(String.format("/repos/%s/%s/pulls?state=%s", owner.login, name, state.name().toLowerCase(Locale.ENGLISH)), GHPullRequest[].class)) {
                     @Override
                     protected void wrapUp(GHPullRequest[] page) {
                         for (GHPullRequest pr : page)
@@ -387,14 +383,54 @@ public class GHRepository {
      */
     public List<GHHook> getHooks() throws IOException {
         List<GHHook> list = new ArrayList<GHHook>(Arrays.asList(
-                root.retrieveWithAuth(String.format("/repos/%s/%s/hooks", owner.login, name), GHHook[].class)));
+                root.retrieve().to(String.format("/repos/%s/%s/hooks", owner.login, name), GHHook[].class)));
         for (GHHook h : list)
             h.wrap(this);
         return list;
     }
 
     public GHHook getHook(int id) throws IOException {
-        return root.retrieveWithAuth(String.format("/repos/%s/%s/hooks/%d", owner.login, name, id), GHHook.class).wrap(this);
+        return root.retrieve().to(String.format("/repos/%s/%s/hooks/%d", owner.login, name, id), GHHook.class).wrap(this);
+    }
+
+    /**
+     * Gets a comparison between 2 points in the repository. This would be similar
+     * to calling <tt>git log id1...id2</tt> against a local repository.
+     * @param id1 an identifier for the first point to compare from, this can be a sha1 ID (for a commit, tag etc) or a direct tag name
+     * @param id2 an identifier for the second point to compare to. Can be the same as the first point.
+     * @return the comparison output
+     * @throws IOException on failure communicating with GitHub
+     */
+    public GHCompare getCompare(String id1, String id2) throws IOException {
+        GHCompare compare = root.retrieve().to(String.format("/repos/%s/%s/compare/%s...%s", owner.login, name, id1, id2), GHCompare.class);
+        return compare.wrap(this);
+    }
+
+    public GHCompare getCompare(GHCommit id1, GHCommit id2) throws IOException {
+        return getCompare(id1.getSHA1(),id2.getSHA1());
+    }
+
+    public GHCompare getCompare(GHBranch id1, GHBranch id2) throws IOException {
+        return getCompare(id1.getName(),id2.getName());
+    }
+
+    /**
+     * Retrieves all refs for the github repository.
+     * @return an array of GHRef elements coresponding with the refs in the remote repository.
+     * @throws IOException on failure communicating with GitHub
+     */
+    public GHRef[] getRefs() throws IOException {
+       return root.retrieve().to(String.format("/repos/%s/%s/git/refs", owner.login, name), GHRef[].class);
+    }
+
+    /**
+     * Retrienved all refs of the given type for the current GitHub repository.
+     * @param refType the type of reg to search for e.g. <tt>tags</tt> or <tt>commits</tt>
+     * @return an array of all refs matching the request type
+     * @throws IOException on failure communicating with GitHub, potentially due to an invalid ref type being requested
+     */
+    public GHRef[] getRefs(String refType) throws IOException {
+        return root.retrieve().to(String.format("/repos/%s/%s/git/refs/%s", owner.login, name, refType), GHRef[].class);
     }
 
     /**
@@ -403,7 +439,7 @@ public class GHRepository {
     public GHCommit getCommit(String sha1) throws IOException {
         GHCommit c = commits.get(sha1);
         if (c==null) {
-            c = root.retrieve(String.format("/repos/%s/%s/commits/%s", owner.login, name, sha1), GHCommit.class).wrapUp(this);
+            c = root.retrieve().to(String.format("/repos/%s/%s/commits/%s", owner.login, name, sha1), GHCommit.class).wrapUp(this);
             commits.put(sha1,c);
         }
         return c;
@@ -415,7 +451,7 @@ public class GHRepository {
     public PagedIterable<GHCommit> listCommits() {
         return new PagedIterable<GHCommit>() {
             public PagedIterator<GHCommit> iterator() {
-                return new PagedIterator<GHCommit>(root.retrievePaged(String.format("/repos/%s/%s/commits",owner.login,name),GHCommit[].class,false)) {
+                return new PagedIterator<GHCommit>(root.retrieve().asIterator(String.format("/repos/%s/%s/commits", owner.login, name), GHCommit[].class)) {
                     protected void wrapUp(GHCommit[] page) {
                         for (GHCommit c : page)
                             c.wrapUp(GHRepository.this);
@@ -431,7 +467,7 @@ public class GHRepository {
     public PagedIterable<GHCommitComment> listCommitComments() {
         return new PagedIterable<GHCommitComment>() {
             public PagedIterator<GHCommitComment> iterator() {
-                return new PagedIterator<GHCommitComment>(root.retrievePaged(String.format("/repos/%s/%s/comments",owner.login,name),GHCommitComment[].class,false)) {
+                return new PagedIterator<GHCommitComment>(root.retrieve().asIterator(String.format("/repos/%s/%s/comments", owner.login, name), GHCommitComment[].class)) {
                     @Override
                     protected void wrapUp(GHCommitComment[] page) {
                         for (GHCommitComment c : page)
@@ -442,6 +478,48 @@ public class GHRepository {
         };
     }
 
+    /**
+     * Lists all the commit statues attached to the given commit, newer ones first.
+     */
+    public PagedIterable<GHCommitStatus> listCommitStatuses(final String sha1) throws IOException {
+        return new PagedIterable<GHCommitStatus>() {
+            public PagedIterator<GHCommitStatus> iterator() {
+                return new PagedIterator<GHCommitStatus>(root.retrieve().asIterator(String.format("/repos/%s/%s/statuses/%s", owner.login, name, sha1), GHCommitStatus[].class)) {
+                    @Override
+                    protected void wrapUp(GHCommitStatus[] page) {
+                        for (GHCommitStatus c : page)
+                            c.wrapUp(root);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Gets the last status of this commit, which is what gets shown in the UI.
+     */
+    public GHCommitStatus getLastCommitStatus(String sha1) throws IOException {
+        List<GHCommitStatus> v = listCommitStatuses(sha1).asList();
+        return v.isEmpty() ? null : v.get(0);
+    }
+
+    /**
+     * Creates a commit status
+     *
+     * @param targetUrl
+     *      Optional parameter that points to the URL that has more details.
+     * @param description
+     *      Optional short description.
+     */
+    public GHCommitStatus createCommitStatus(String sha1, GHCommitState state, String targetUrl, String description) throws IOException {
+        return new Requester(root)
+                .with("state", state.name().toLowerCase(Locale.ENGLISH))
+                .with("target_url", targetUrl)
+                .with("description", description)
+                .to(String.format("/repos/%s/%s/statuses/%s",owner.login,this.name,sha1),GHCommitStatus.class).wrapUp(root);
+    }
+
+
     /**
      * 
      * See https://api.github.com/hooks for possible names and their configuration scheme.
@@ -462,9 +540,8 @@ public class GHRepository {
                 ea.add(e.name().toLowerCase(Locale.ENGLISH));
         }
 
-        return new Poster(root)
-                .withCredential()
-                .with("name",name)
+        return new Requester(root)
+                .with("name", name)
                 .with("active", active)
                 ._with("config", config)
                 ._with("events",ea)
@@ -568,28 +645,46 @@ public class GHRepository {
      */
     public Map<String,GHBranch> getBranches() throws IOException {
         Map<String,GHBranch> r = new TreeMap<String,GHBranch>();
-        for (GHBranch p : root.retrieve("/repos/" + owner.login + "/" + name + "/branches", GHBranch[].class)) {
+        for (GHBranch p : root.retrieve().to(getApiTailUrl("branches"), GHBranch[].class)) {
             p.wrap(this);
             r.put(p.getName(),p);
         }
         return r;
     }
 
+    /**
+     * @deprecated
+     *      Use {@link #listMilestones(GHIssueState)}
+     */
     public Map<Integer, GHMilestone> getMilestones() throws IOException {
         Map<Integer,GHMilestone> milestones = new TreeMap<Integer, GHMilestone>();
-    	GHMilestone[] ms = root.retrieve("/repos/" + owner.login + "/" + name + "/milestones", GHMilestone[].class);
-    	for (GHMilestone m : ms) {
-    		m.owner = this;
-    		m.root = root;
+    	for (GHMilestone m : listMilestones(GHIssueState.OPEN)) {
     		milestones.put(m.getNumber(), m);
     	}
     	return milestones;
     }
 
+    /**
+     * Lists up all the milestones in this repository.
+     */
+    public PagedIterable<GHMilestone> listMilestones(final GHIssueState state) {
+        return new PagedIterable<GHMilestone>() {
+            public PagedIterator<GHMilestone> iterator() {
+                return new PagedIterator<GHMilestone>(root.retrieve().asIterator(getApiTailUrl("milestones?state="+state.toString().toLowerCase(Locale.ENGLISH)), GHMilestone[].class)) {
+                    @Override
+                    protected void wrapUp(GHMilestone[] page) {
+                        for (GHMilestone c : page)
+                            c.wrap(GHRepository.this);
+                    }
+                };
+            }
+        };
+    }
+
 	public GHMilestone getMilestone(int number) throws IOException {
 		GHMilestone m = milestones.get(number);
 		if (m == null) {
-			m = root.retrieve("/repos/" + owner.login + "/" + name + "/milestones/" + number, GHMilestone.class);
+            m = root.retrieve().to(getApiTailUrl("milestones/" + number), GHMilestone.class);
     		m.owner = this;
     		m.root = root;
 			milestones.put(m.getNumber(), m);
@@ -598,9 +693,8 @@ public class GHRepository {
 	}
 	
 	public GHMilestone createMilestone(String title, String description) throws IOException {
-        return new Poster(root).withCredential()
-                .with("title", title).with("description", description)
-                .to("/repos/"+owner.login+"/"+name+"/milestones", GHMilestone.class,"POST").wrap(this);
+        return new Requester(root)
+                .with("title", title).with("description", description).method("POST").to(getApiTailUrl("milestones"), GHMilestone.class).wrap(this);
 	}
 
     @Override
@@ -622,4 +716,8 @@ public class GHRepository {
         }
         return false;
     }
+
+    String getApiTailUrl(String tail) {
+        return "/repos/" + owner.login + "/" + name +'/'+tail;
+    }
 }

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

@@ -46,11 +46,11 @@ public class GHTeam {
      * Retrieves the current members.
      */
     public Set<GHUser> getMembers() throws IOException {
-        return new HashSet<GHUser>(Arrays.asList(GHUser.wrap(org.root.retrieveWithAuth(api("/members"), GHUser[].class), org.root)));
+        return new HashSet<GHUser>(Arrays.asList(GHUser.wrap(org.root.retrieve().to(api("/members"), GHUser[].class), org.root)));
     }
 
     public Map<String,GHRepository> getRepositories() throws IOException {
-        GHRepository[] repos = org.root.retrieveWithAuth(api("/repos"), GHRepository[].class);
+        GHRepository[] repos = org.root.retrieve().to(api("/repos"), GHRepository[].class);
         Map<String,GHRepository> m = new TreeMap<String, GHRepository>();
         for (GHRepository r : repos) {
             m.put(r.getName(),r.wrap(org.root));
@@ -62,22 +62,22 @@ public class GHTeam {
      * Adds a member to the team.
      */
     public void add(GHUser u) throws IOException {
-        org.root.retrieveWithAuth(api("/members/" + u.getLogin()), null, "PUT");
+        org.root.retrieve().method("PUT").to(api("/members/" + u.getLogin()), null);
     }
 
     /**
      * Removes a member to the team.
      */
     public void remove(GHUser u) throws IOException {
-        org.root.retrieveWithAuth(api("/members/" + u.getLogin()), null, "DELETE");
+        org.root.retrieve().method("DELETE").to(api("/members/" + u.getLogin()), null);
     }
 
     public void add(GHRepository r) throws IOException {
-        org.root.retrieveWithAuth(api("/repos/" + r.getOwnerName() + '/' + r.getName()), null, "PUT");
+        org.root.retrieve().method("PUT").to(api("/repos/" + r.getOwnerName() + '/' + r.getName()), null);
     }
 
     public void remove(GHRepository r) throws IOException {
-        org.root.retrieveWithAuth(api("/repos/" + r.getOwnerName() + '/' + r.getName()), null, "DELETE");
+        org.root.retrieve().method("DELETE").to(api("/repos/" + r.getOwnerName() + '/' + r.getName()), null);
     }
 
     private String api(String tail) {

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

@@ -41,14 +41,14 @@ public class GHUser extends GHPerson {
      * Follow this user.
      */
     public void follow() throws IOException {
-        new Poster(root).withCredential().to("/user/following/"+login,null,"PUT");
+        new Requester(root).method("PUT").to("/user/following/" + login);
     }
 
     /**
      * Unfollow this user.
      */
     public void unfollow() throws IOException {
-        new Poster(root).withCredential().to("/user/following/"+login,null,"DELETE");
+        new Requester(root).method("DELETE").to("/user/following/" + login);
     }
 
     /**
@@ -56,7 +56,7 @@ public class GHUser extends GHPerson {
      */
     @WithBridgeMethods(Set.class)
     public GHPersonSet<GHUser> getFollows() throws IOException {
-        GHUser[] followers = root.retrieve("/users/" + login + "/following", GHUser[].class);
+        GHUser[] followers = root.retrieve().to("/users/" + login + "/following", GHUser[].class);
         return new GHPersonSet<GHUser>(Arrays.asList(wrap(followers,root)));
     }
 
@@ -65,10 +65,24 @@ public class GHUser extends GHPerson {
      */
     @WithBridgeMethods(Set.class)
     public GHPersonSet<GHUser> getFollowers() throws IOException {
-        GHUser[] followers = root.retrieve("/users/" + login + "/followers", GHUser[].class);
+        GHUser[] followers = root.retrieve().to("/users/" + login + "/followers", GHUser[].class);
         return new GHPersonSet<GHUser>(Arrays.asList(wrap(followers,root)));
     }
 
+    /**
+     * Returns true if this user belongs to the specified organization.
+     */
+    public boolean isMemberOf(GHOrganization org) {
+        return org.hasMember(this);
+    }
+
+    /**
+     * Returns true if this user belongs to the specified 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;
@@ -82,7 +96,7 @@ public class GHUser extends GHPerson {
     public GHPersonSet<GHOrganization> getOrganizations() throws IOException {
         GHPersonSet<GHOrganization> orgs = new GHPersonSet<GHOrganization>();
         Set<String> names = new HashSet<String>();
-        for (GHOrganization o : root.retrieve("/users/" + login + "/orgs", GHOrganization[].class)) {
+        for (GHOrganization o : root.retrieve().to("/users/" + login + "/orgs", GHOrganization[].class)) {
             if (names.add(o.getLogin()))    // I've seen some duplicates in the data
                 orgs.add(root.getOrganization(o.getLogin()));
         }

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

@@ -23,44 +23,31 @@
  */
 package org.kohsuke.github;
 
-import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.ANY;
-import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.NONE;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.InterruptedIOException;
-import java.io.Reader;
-import java.net.HttpURLConnection;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Properties;
-import java.util.TimeZone;
-import java.util.zip.GZIPInputStream;
-
 import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
+import org.apache.commons.codec.binary.Base64;
 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 java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.Reader;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TimeZone;
 
-import com.gargoylesoftware.htmlunit.WebClient;
-import com.gargoylesoftware.htmlunit.html.HtmlForm;
-import com.gargoylesoftware.htmlunit.html.HtmlPage;
+import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.*;
 
 /**
  * Root of the GitHub API.
@@ -69,51 +56,78 @@ import com.gargoylesoftware.htmlunit.html.HtmlPage;
  */
 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 githubServer;
 
-	private GitHub(String login, String apiToken, String password) {
-		this ("github.com", login, apiToken, password);
-	}
+    private final String apiUrl;
 
     /**
-     *
-     * @param githubServer
-     *      The host name of the GitHub (or GitHub enterprise) server, such as "github.com".
+     * Connects to GitHub.com
      */
-    private GitHub(String githubServer, String login, String apiToken, String password) {
-        this.githubServer = githubServer;
-		this.login = login;
-        this.apiToken = apiToken;
-        this.password = password;
-
-        BASE64Encoder enc = new sun.misc.BASE64Encoder();
-        if (apiToken!=null || password!=null) {
-            String userpassword = password==null ? (login + "/token" + ":" + apiToken) : (login + ':'+password);
-            encodedAuthorization = enc.encode(userpassword.getBytes());
-        } else
-            encodedAuthorization = null;
+    private GitHub(String login, String oauthAccessToken, String password) throws IOException {
+      this (GITHUB_URL, login, oauthAccessToken, password);
     }
 
-    private GitHub (String githubServer, String oauthAccessToken) throws IOException {
-    	
-		this.githubServer = githubServer;
-		this.password = null;
-		this.encodedAuthorization = null;
-		
-		this.oauthAccessToken = oauthAccessToken;
-        this.apiToken = oauthAccessToken;
-		
-		this.login = getMyself().getLogin();
+    /**
+     * Creates a client API root object.
+     *
+     * <p>
+     * Several different combinations of the login/oauthAccessToken/password parameters are allowed
+     * to represent different ways of authentication.
+     *
+     * <dl>
+     *     <dt>Loging anonymously
+     *     <dd>Leave all three parameters null and you will be making HTTP requests without any authentication.
+     *
+     *     <dt>Log in with password
+     *     <dd>Specify the login and password, then leave oauthAccessToken null.
+     *         This will use the HTTP BASIC auth with the GitHub API.
+     *
+     *     <dt>Log in with OAuth token
+     *     <dd>Specify oauthAccessToken, and optionally specify the login. Leave password null.
+     *         This will send OAuth token to the GitHub API. If the login parameter is null,
+     *         The constructor makes an API call to figure out the user name that owns the token.
+     * </dl>
+     *
+     * @param apiUrl
+     *      The URL of GitHub (or GitHub enterprise) API endpoint, such as "https://api.github.com" or
+     *      "http://ghe.acme.com/api/v3". Note that GitHub Enterprise has <tt>/api/v3</tt> in the URL.
+     *      For historical reasons, this parameter still accepts the bare domain name, but that's considered deprecated.
+     *      Password is also considered deprecated as it is no longer required for api usage.
+     * @param login
+     *      The use ID on GitHub that you are logging in as. Can be omitted if the OAuth token is
+     *      provided or if logging in anonymously. Specifying this would save one API call.
+     * @param oauthAccessToken
+     *      Secret OAuth token.
+     * @param password
+     *      User's password. Always used in conjunction with the {@code login} parameter
+     */
+    private GitHub(String apiUrl, String login, String oauthAccessToken, String password) throws IOException {
+        if (apiUrl.endsWith("/")) apiUrl = apiUrl.substring(0, apiUrl.length()-1); // normalize
+        this.apiUrl = apiUrl;
+
+        if (oauthAccessToken!=null) {
+            encodedAuthorization = "token "+oauthAccessToken;
+        } else {
+            if (password!=null) {
+                String authorization = (login + ':' + password);
+                encodedAuthorization = "Basic "+new String(Base64.encodeBase64(authorization.getBytes()));
+            } else {// anonymous access
+                encodedAuthorization = null;
+            }
+        }
+
+        if (login==null && encodedAuthorization!=null)
+            login = getMyself().getLogin();
+        this.login = login;
     }
-    
+
     /**
      * Obtains the credential from "~/.github"
      */
@@ -126,233 +140,92 @@ public class GitHub {
         } finally {
             IOUtils.closeQuietly(in);
         }
-        return new GitHub(props.getProperty("login"),props.getProperty("token"),props.getProperty("password"));
+        return new GitHub(GITHUB_URL,props.getProperty("login"), props.getProperty("oauth"),props.getProperty("password"));
     }
 
-    public static GitHub connect(String login, String apiToken) throws IOException {
-        return new GitHub(login,apiToken,null);
+    /**
+     * Version that connects to GitHub Enterprise.
+     *
+     * @param apiUrl
+     *      The URL of GitHub (or GitHub enterprise) API endpoint, such as "https://api.github.com" or
+     *      "http://ghe.acme.com/api/v3". Note that GitHub Enterprise has <tt>/api/v3</tt> in the URL.
+     *      For historical reasons, this parameter still accepts the bare domain name, but that's considered deprecated.
+     */
+    public static GitHub connectToEnterprise(String apiUrl, String oauthAccessToken) throws IOException {
+        return connectUsingOAuth(apiUrl, oauthAccessToken);
     }
 
-    public static GitHub connect(String login, String apiToken, String password) throws IOException {
-        return new GitHub(login,apiToken,password);
+    public static GitHub connectToEnterprise(String apiUrl, String login, String password) throws IOException {
+        return new GitHub(apiUrl, login, null, password);
     }
 
-    public static GitHub connectUsingOAuth (String accessToken) throws IOException {
-    	return connectUsingOAuth("github.com", accessToken);
+    public static GitHub connect(String login, String oauthAccessToken) throws IOException {
+        return new GitHub(login,oauthAccessToken,null);
     }
-    
-    public static GitHub connectUsingOAuth (String githubServer, String accessToken) throws IOException {
-    	return new GitHub(githubServer, 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 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;
+    }
+
     /*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;
-    	}
-    	
-        return new URL("https://api."+githubServer+tailApiUrl);
-    }
-
-    /*package*/ <T> T retrieve(String tailApiUrl, Class<T> type) throws IOException {
-        return _retrieve(tailApiUrl, type, "GET", false);
-    }
-
-    /*package*/ <T> T retrieveWithAuth(String tailApiUrl, Class<T> type) throws IOException {
-        return _retrieve(tailApiUrl, type, "GET", true);
-    }
-
-    /*package*/ <T> T retrieveWithAuth(String tailApiUrl, Class<T> type, String method) throws IOException {
-        return _retrieve(tailApiUrl, type, method, true);
-    }
-
-    private <T> T _retrieve(String tailApiUrl, Class<T> type, String method, boolean withAuth) throws IOException {
-        while (true) {// loop while API rate limit is hit
-            HttpURLConnection uc = setupConnection(method, withAuth, getApiURL(tailApiUrl));
-            try {
-                return parse(uc,type);
-            } catch (IOException e) {
-                handleApiError(e,uc);
+        if (tailApiUrl.startsWith("/")) {
+            if ("github.com".equals(apiUrl)) {// backward compatibility
+                return new URL(GITHUB_URL + tailApiUrl);
+            } else {
+                return new URL(apiUrl + tailApiUrl);
             }
+        } else {
+            return new URL(tailApiUrl);
         }
     }
 
-    /**
-     * Loads pagenated resources.
-     *
-     * Every iterator call reports a new batch.
-     */
-    /*package*/ <T> Iterator<T> retrievePaged(final String tailApiUrl, final Class<T> type, final boolean withAuth) {
-        return new Iterator<T>() {
-            /**
-             * The next batch to be returned from {@link #next()}.
-             */
-            T next;
-            /**
-             * URL of the next resource to be retrieved, or null if no more data is available.
-             */
-            URL url;
-
-            {
-                try {
-                    url = getApiURL(tailApiUrl);
-                } catch (IOException e) {
-                    throw new Error(e);
-                }
-            }
-
-            public boolean hasNext() {
-                fetch();
-                return next!=null;
-            }
-
-            public T next() {
-                fetch();
-                T r = next;
-                if (r==null)    throw new NoSuchElementException();
-                next = null;
-                return r;
-            }
-
-            public void remove() {
-                throw new UnsupportedOperationException();
-            }
-
-            private void fetch() {
-                if (next!=null) return; // already fetched
-                if (url==null)  return; // no more data to fetch
-
-                try {
-                    while (true) {// loop while API rate limit is hit
-                        HttpURLConnection uc = setupConnection("GET", withAuth, url);
-                        try {
-                            next = parse(uc,type);
-                            assert next!=null;
-                            findNextURL(uc);
-                            return;
-                        } catch (IOException e) {
-                            handleApiError(e,uc);
-                        }
-                    }
-                } catch (IOException e) {
-                    throw new Error(e);
-                }
-            }
-
-            /**
-             * Locate the next page from the pagination "Link" tag.
-             */
-            private void findNextURL(HttpURLConnection uc) throws MalformedURLException {
-                url = null; // start defensively
-                String link = uc.getHeaderField("Link");
-                if (link==null) return;
-
-                for (String token : link.split(", ")) {
-                    if (token.endsWith("rel=\"next\"")) {
-                        // found the next page. This should look something like
-                        // <https://api.github.com/repos?page=3&per_page=100>; rel="next"
-                        int idx = token.indexOf('>');
-                        url = new URL(token.substring(1,idx));
-                        return;
-                    }
-                }
-
-                // no more "next" link. we are done.
-            }
-        };
-    }
-
-    private HttpURLConnection setupConnection(String method, boolean withAuth, URL url) throws IOException {
-        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
-
-        // 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 (withAuth && encodedAuthorization!=null && this.oauthAccessToken == null)
-            uc.setRequestProperty("Authorization", "Basic " + encodedAuthorization);
-
-        uc.setRequestMethod(method);
-        uc.setRequestProperty("Accept-Encoding", "gzip");
-        if (method.equals("PUT")) {
-            uc.setDoOutput(true);
-            uc.setRequestProperty("Content-Length","0");
-            uc.getOutputStream().close();
-        }
-        return uc;
-    }
-
-    private <T> T parse(HttpURLConnection uc, Class<T> type) throws IOException {
-        InputStreamReader r = null;
-        try {
-            r = new InputStreamReader(wrapStream(uc, uc.getInputStream()), "UTF-8");
-            if (type==null) {
-                String data = IOUtils.toString(r);
-                return null;
-            }
-            return MAPPER.readValue(r,type);
-        } finally {
-            IOUtils.closeQuietly(r);
-        }
-    }
-
-    /**
-     * Handles the "Content-Encoding" header.
-     */
-    private InputStream wrapStream(HttpURLConnection uc, InputStream in) throws IOException {
-        String encoding = uc.getContentEncoding();
-        if (encoding==null || in==null) return in;
-        if (encoding.equals("gzip"))    return new GZIPInputStream(in);
-
-        throw new UnsupportedOperationException("Unexpected Content-Encoding: "+encoding);
-    }
-
-    /**
-     * If the error is because of the API limit, wait 10 sec and return normally.
-     * Otherwise throw an exception reporting an error.
-     */
-    /*package*/ void handleApiError(IOException e, HttpURLConnection uc) throws IOException {
-        if ("0".equals(uc.getHeaderField("X-RateLimit-Remaining"))) {
-            // API limit reached. wait 10 secs and return normally
-            try {
-                Thread.sleep(10000);
-                return;
-            } catch (InterruptedException _) {
-                throw (InterruptedIOException)new InterruptedIOException().initCause(e);
-            }
-        }
-        
-        if (e instanceof FileNotFoundException)
-            throw e;    // pass through 404 Not Found to allow the caller to handle it intelligently
-
-        InputStream es = wrapStream(uc, uc.getErrorStream());
-        try {
-            if (es!=null)
-                throw (IOException)new IOException(IOUtils.toString(es,"UTF-8")).initCause(e);
-            else
-                throw e;
-        } finally {
-            IOUtils.closeQuietly(es);
-        }
+    /*package*/ Requester retrieve() {
+        return new Requester(this).method("GET");
     }
 
     /**
      * Gets the current rate limit.
      */
     public GHRateLimit getRateLimit() throws IOException {
-        return retrieveWithAuth("/rate_limit", JsonRateLimit.class).rate;
+        return retrieve().to("/rate_limit", JsonRateLimit.class).rate;
     }
 
     /**
@@ -362,7 +235,7 @@ public class GitHub {
 	public GHMyself getMyself() throws IOException {
 		requireCredential();
 
-        GHMyself u = retrieveWithAuth("/user", GHMyself.class);
+        GHMyself u = retrieve().to("/user", GHMyself.class);
 
         u.root = this;
         users.put(u.getLogin(), u);
@@ -376,7 +249,7 @@ public class GitHub {
 	public GHUser getUser(String login) throws IOException {
 		GHUser u = users.get(login);
 		if (u == null) {
-            u = retrieve("/users/" + login, GHUser.class);
+            u = retrieve().to("/users/" + login, GHUser.class);
             u.root = this;
             users.put(u.getLogin(), u);
 		}
@@ -399,7 +272,7 @@ public class GitHub {
     public GHOrganization getOrganization(String name) throws IOException {
         GHOrganization o = orgs.get(name);
         if (o==null) {
-            o = retrieve("/orgs/" + name, GHOrganization.class).wrapUp(this);
+            o = retrieve().to("/orgs/" + name, GHOrganization.class).wrapUp(this);
             orgs.put(name,o);
         }
         return o;
@@ -412,7 +285,7 @@ public class GitHub {
      */
     public GHRepository getRepository(String name) throws IOException {
         String[] tokens = name.split("/");
-        return getUser(tokens[0]).getRepository(tokens[1]);
+        return retrieve().to("/repos/" + tokens[0] + '/' + tokens[1], GHRepository.class).wrap(this);
     }
 
     /**
@@ -422,7 +295,7 @@ public class GitHub {
      * TODO: make this automatic.
      */
     public Map<String, GHOrganization> getMyOrganizations() throws IOException {
-        GHOrganization[] orgs = retrieveWithAuth("/user/orgs", GHOrganization[].class);
+        GHOrganization[] orgs = retrieve().to("/user/orgs", GHOrganization[].class);
         Map<String, GHOrganization> r = new HashMap<String, GHOrganization>();
         for (GHOrganization o : orgs) {
             // don't put 'o' into orgs because they are shallow
@@ -435,8 +308,8 @@ 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
-        GHEventInfo[] events = retrieve("/events", GHEventInfo[].class);
+        // TODO: pagination
+        GHEventInfo[] events = retrieve().to("/events", GHEventInfo[].class);
         for (GHEventInfo e : events)
             e.wrapUp(this);
         return Arrays.asList(events);
@@ -454,7 +327,7 @@ public class GitHub {
         t.wrapUp(this);
         return t;
     }
-    
+
     /**
      * Creates a new repository.
      *
@@ -462,35 +335,40 @@ public class GitHub {
      *      Newly created repository.
      */
     public GHRepository createRepository(String name, String description, String homepage, boolean isPublic) throws IOException {
-        return new Poster(this).withCredential()
+        Requester requester = new Requester(this)
                 .with("name", name).with("description", description).with("homepage", homepage)
-                .with("public", isPublic ? 1 : 0).to("/user/repos", GHRepository.class,"POST").wrap(this);
+                .with("public", isPublic ? 1 : 0);
+        return requester.method("POST").to("/user/repos", GHRepository.class).wrap(this);
     }
 
+    /**
+     * Creates a new authorization.
+     *
+     * The token created can be then used for {@link GitHub#connectUsingOAuth(String)} in the future.
+     *
+     * @see <a href="http://developer.github.com/v3/oauth/#create-a-new-authorization">Documentation</a>
+     */
+	public GHAuthorization createToken(Collection<String> scope, String note, String noteUrl) throws IOException{
+		Requester requester = new Requester(this)
+				.with("scopes", scope)
+				.with("note", note)
+				.with("note_url", noteUrl);
+
+		return requester.method("POST").to("/authorizations", GHAuthorization.class).wrap(this);
+	}
+
     /**
      * Ensures that the credential is valid.
      */
     public boolean isCredentialValid() throws IOException {
         try {
-            retrieveWithAuth("/user", GHUser.class);
+            retrieve().to("/user", GHUser.class);
             return true;
         } catch (IOException e) {
             return false;
         }
     }
 
-    WebClient createWebClient() throws IOException {
-        WebClient wc = new WebClient();
-        wc.setJavaScriptEnabled(false);
-        wc.setCssEnabled(false);
-        HtmlPage pg = (HtmlPage)wc.getPage("https://github.com/login");
-        HtmlForm f = pg.getForms().get(0);
-        f.getInputByName("login").setValueAttribute(login);
-        f.getInputByName("password").setValueAttribute(password);
-        f.submit();
-        return wc;
-    }
-
     /*package*/ static URL parseURL(String s) {
         try {
             return s==null ? null : new URL(s);
@@ -521,4 +399,6 @@ public class GitHub {
         MAPPER.setVisibilityChecker(new Std(NONE, NONE, NONE, NONE, ANY));
         MAPPER.getDeserializationConfig().set(Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
     }
+
+    private static final String GITHUB_URL = "https://api.github.com";
 }

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

@@ -3,6 +3,7 @@ package org.kohsuke.github;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 /**
  * Iterator over a pagenated data source.
@@ -28,17 +29,24 @@ public abstract class PagedIterator<T> implements Iterator<T> {
     protected abstract void wrapUp(T[] page);
 
     public boolean hasNext() {
-        return (current!=null && pos<current.length) || base.hasNext();
+        fetch();
+        return current!=null;
     }
 
     public T next() {
         fetch();
-
+        if (current==null)  throw new NoSuchElementException();
         return current[pos++];
     }
 
     private void fetch() {
         while (current==null || current.length<=pos) {
+            if (!base.hasNext()) {// no more to retrieve
+                current = null;
+                pos = 0;
+                return;
+            }
+
             current = base.next();
             wrapUp(current);
             pos = 0;

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

@@ -1,163 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright (c) 2010, Kohsuke Kawaguchi
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-package org.kohsuke.github;
-
-import org.apache.commons.io.IOUtils;
-
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.lang.reflect.Field;
-import java.net.HttpURLConnection;
-import java.net.ProtocolException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.kohsuke.github.GitHub.*;
-
-/**
- * Handles HTTP POST.
- * @author Kohsuke Kawaguchi
- */
-class Poster {
-    private final GitHub root;
-    private final List<Entry> args = new ArrayList<Entry>();
-    private boolean authenticate;
-
-    private static class Entry {
-        String key;
-        Object value;
-
-        private Entry(String key, Object value) {
-            this.key = key;
-            this.value = value;
-        }
-    }
-
-    Poster(GitHub root) {
-        this.root = root;
-    }
-
-    public Poster withCredential() {
-        root.requireCredential();
-        authenticate = true;
-        return this;
-    }
-
-    public Poster with(String key, int value) {
-        return _with(key, value);
-    }
-
-    public Poster with(String key, Integer value) {
-        if (value!=null)
-            _with(key, value.intValue());
-        return this;
-    }
-
-    public Poster with(String key, boolean value) {
-        return _with(key, value);
-    }
-
-    public Poster with(String key, String value) {
-        return _with(key, value);
-    }
-
-    public Poster with(String key, Collection<String> value) {
-        return _with(key, value);
-    }
-
-    public Poster _with(String key, Object value) {
-        if (value!=null) {
-            args.add(new Entry(key,value));
-        }
-        return this;
-    }
-
-    public void to(String tailApiUrl) throws IOException {
-        to(tailApiUrl,null);
-    }
-
-    /**
-     * POSTs the form to the specified URL.
-     *
-     * @throws IOException
-     *      if the server returns 4xx/5xx responses.
-     * @return
-     *      {@link Reader} that reads the response.
-     */
-    public <T> T to(String tailApiUrl, Class<T> type) throws IOException {
-        return to(tailApiUrl,type,"POST");
-    }
-
-    public <T> T to(String tailApiUrl, Class<T> type, String method) throws IOException {
-        while (true) {// loop while API rate limit is hit
-            HttpURLConnection uc = (HttpURLConnection) root.getApiURL(tailApiUrl).openConnection();
-
-            uc.setDoOutput(true);
-            uc.setRequestProperty("Content-type","application/x-www-form-urlencoded");
-            if (authenticate) {
-                if (root.oauthAccessToken!=null) {
-                    uc.setRequestProperty("Authorization", "token " + root.oauthAccessToken);
-                } else {
-                    if (root.password==null)
-                        throw new IllegalArgumentException("V3 API doesn't support API token");
-                    uc.setRequestProperty("Authorization", "Basic " + root.encodedAuthorization);
-                }
-            }
-            try {
-                uc.setRequestMethod(method);
-            } catch (ProtocolException e) {
-                // JDK only allows one of the fixed set of verbs. Try to override that
-                try {
-                    Field $method = HttpURLConnection.class.getDeclaredField("method");
-                    $method.setAccessible(true);
-                    $method.set(uc,method);
-                } catch (Exception x) {
-                    throw (IOException)new IOException("Failed to set the custom verb").initCause(x);
-                }
-            }
-
-
-            Map json = new HashMap();
-            for (Entry e : args) {
-                json.put(e.key, e.value);
-            }
-            MAPPER.writeValue(uc.getOutputStream(),json);
-
-            try {
-                InputStreamReader r = new InputStreamReader(uc.getInputStream(), "UTF-8");
-                String data = IOUtils.toString(r);
-                if (type==null) {
-                    return null;
-                }
-                return MAPPER.readValue(data,type);
-            } catch (IOException e) {
-                root.handleApiError(e,uc);
-            }
-        }
-    }
-}

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

@@ -0,0 +1,356 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2010, Kohsuke Kawaguchi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package org.kohsuke.github;
+
+import org.apache.commons.io.IOUtils;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.InterruptedIOException;
+import java.io.Reader;
+import java.lang.reflect.Field;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.ProtocolException;
+import java.net.URL;
+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.*;
+
+/**
+ * A builder pattern for making HTTP call and parsing its output.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+class Requester {
+    private final GitHub root;
+    private final List<Entry> args = new ArrayList<Entry>();
+
+    /**
+     * Request method.
+     */
+    private String method = "POST";
+
+    private static class Entry {
+        String key;
+        Object value;
+
+        private Entry(String key, Object value) {
+            this.key = key;
+            this.value = value;
+        }
+    }
+
+    Requester(GitHub root) {
+        this.root = root;
+    }
+
+    /**
+     * Makes a request with authentication credential.
+     */
+    @Deprecated
+    public Requester withCredential() {
+        // keeping it inline with retrieveWithAuth not to enforce the check
+        // root.requireCredential();
+        return this;
+    }
+
+    public Requester with(String key, int value) {
+        return _with(key, value);
+    }
+
+    public Requester with(String key, Integer value) {
+        if (value!=null)
+            _with(key, value.intValue());
+        return this;
+    }
+
+    public Requester with(String key, boolean value) {
+        return _with(key, value);
+    }
+
+    public Requester with(String key, String value) {
+        return _with(key, value);
+    }
+
+    public Requester with(String key, Collection<String> value) {
+        return _with(key, value);
+    }
+
+    public Requester with(String key, Map<String, String> value) {
+        return _with(key, value);
+    }
+
+    public Requester _with(String key, Object value) {
+        if (value!=null) {
+            args.add(new Entry(key,value));
+        }
+        return this;
+    }
+
+    public Requester method(String method) {
+        this.method = method;
+        return this;
+    }
+
+    public void to(String tailApiUrl) throws IOException {
+        to(tailApiUrl,null);
+    }
+
+    /**
+     * Sends a request to the specified URL, and parses the response into the given type via databinding.
+     *
+     * @throws IOException
+     *      if the server returns 4xx/5xx responses.
+     * @return
+     *      {@link Reader} that reads the response.
+     */
+    public <T> T to(String tailApiUrl, Class<T> type) throws IOException {
+        return _to(tailApiUrl, type, null);
+    }
+
+    /**
+     * Like {@link #to(String, Class)} but updates an existing object instead of creating a new instance.
+     */
+    public <T> T to(String tailApiUrl, T existingInstance) throws IOException {
+        return _to(tailApiUrl, null, existingInstance);
+    }
+
+    /**
+     * Short for {@code method(method).to(tailApiUrl,type)}
+     */
+    @Deprecated
+    public <T> T to(String tailApiUrl, Class<T> type, String method) throws IOException {
+        return method(method).to(tailApiUrl,type);
+    }
+
+    private <T> T _to(String tailApiUrl, Class<T> type, T instance) throws IOException {
+        while (true) {// loop while API rate limit is hit
+            HttpURLConnection uc = setupConnection(root.getApiURL(tailApiUrl));
+
+            if (!method.equals("GET")) {
+                uc.setDoOutput(true);
+                uc.setRequestProperty("Content-type","application/x-www-form-urlencoded");
+
+                Map json = new HashMap();
+                for (Entry e : args) {
+                    json.put(e.key, e.value);
+                }
+                MAPPER.writeValue(uc.getOutputStream(),json);
+            }
+
+            try {
+                return parse(uc,type,instance);
+            } catch (IOException e) {
+                handleApiError(e,uc);
+            }
+        }
+    }
+
+    /**
+     * Loads pagenated resources.
+     *
+     * Every iterator call reports a new batch.
+     */
+    /*package*/ <T> Iterator<T> asIterator(final String tailApiUrl, final Class<T> type) {
+        method("GET");
+        if (!args.isEmpty())    throw new IllegalStateException();
+
+        return new Iterator<T>() {
+            /**
+             * The next batch to be returned from {@link #next()}.
+             */
+            T next;
+            /**
+             * URL of the next resource to be retrieved, or null if no more data is available.
+             */
+            URL url;
+
+            {
+                try {
+                    url = root.getApiURL(tailApiUrl);
+                } catch (IOException e) {
+                    throw new Error(e);
+                }
+            }
+
+            public boolean hasNext() {
+                fetch();
+                return next!=null;
+            }
+
+            public T next() {
+                fetch();
+                T r = next;
+                if (r==null)    throw new NoSuchElementException();
+                next = null;
+                return r;
+            }
+
+            public void remove() {
+                throw new UnsupportedOperationException();
+            }
+
+            private void fetch() {
+                if (next!=null) return; // already fetched
+                if (url==null)  return; // no more data to fetch
+
+                try {
+                    while (true) {// loop while API rate limit is hit
+                        HttpURLConnection uc = setupConnection(url);
+                        try {
+                            next = parse(uc,type,null);
+                            assert next!=null;
+                            findNextURL(uc);
+                            return;
+                        } catch (IOException e) {
+                            handleApiError(e,uc);
+                        }
+                    }
+                } catch (IOException e) {
+                    throw new Error(e);
+                }
+            }
+
+            /**
+             * Locate the next page from the pagination "Link" tag.
+             */
+            private void findNextURL(HttpURLConnection uc) throws MalformedURLException {
+                url = null; // start defensively
+                String link = uc.getHeaderField("Link");
+                if (link==null) return;
+
+                for (String token : link.split(", ")) {
+                    if (token.endsWith("rel=\"next\"")) {
+                        // found the next page. This should look something like
+                        // <https://api.github.com/repos?page=3&per_page=100>; rel="next"
+                        int idx = token.indexOf('>');
+                        url = new URL(token.substring(1,idx));
+                        return;
+                    }
+                }
+
+                // no more "next" link. we are done.
+            }
+        };
+    }
+
+
+    private HttpURLConnection setupConnection(URL url) throws IOException {
+        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
+
+        // if the authentication is needed but no credential is given, try it anyway (so that some calls
+        // that do work with anonymous access in the reduced form should still work.)
+        if (root.encodedAuthorization!=null)
+            uc.setRequestProperty("Authorization", root.encodedAuthorization);
+
+        try {
+            uc.setRequestMethod(method);
+        } catch (ProtocolException e) {
+            // JDK only allows one of the fixed set of verbs. Try to override that
+            try {
+                Field $method = HttpURLConnection.class.getDeclaredField("method");
+                $method.setAccessible(true);
+                $method.set(uc,method);
+            } catch (Exception x) {
+                throw (IOException)new IOException("Failed to set the custom verb").initCause(x);
+            }
+        }
+        uc.setRequestProperty("Accept-Encoding", "gzip");
+        return uc;
+    }
+
+    private <T> T parse(HttpURLConnection uc, Class<T> type, T instance) throws IOException {
+        InputStreamReader r = null;
+        try {
+            r = new InputStreamReader(wrapStream(uc, uc.getInputStream()), "UTF-8");
+            String data = IOUtils.toString(r);
+            if (type!=null)
+                return MAPPER.readValue(data,type);
+            if (instance!=null)
+                return MAPPER.readerForUpdating(instance).<T>readValue(data);
+            return null;
+        } finally {
+            IOUtils.closeQuietly(r);
+        }
+    }
+
+    /**
+     * Handles the "Content-Encoding" header.
+     */
+    private InputStream wrapStream(HttpURLConnection uc, InputStream in) throws IOException {
+        String encoding = uc.getContentEncoding();
+        if (encoding==null || in==null) return in;
+        if (encoding.equals("gzip"))    return new GZIPInputStream(in);
+
+        throw new UnsupportedOperationException("Unexpected Content-Encoding: "+encoding);
+    }
+
+    /**
+     * If the error is because of the API limit, wait 10 sec and return normally.
+     * Otherwise throw an exception reporting an error.
+     */
+    /*package*/ void handleApiError(IOException e, HttpURLConnection uc) throws IOException {
+        if ("0".equals(uc.getHeaderField("X-RateLimit-Remaining"))) {
+            // API limit reached. wait 10 secs and return normally
+            try {
+                Thread.sleep(10000);
+                return;
+            } catch (InterruptedException _) {
+                throw (InterruptedIOException)new InterruptedIOException().initCause(e);
+            }
+        }
+
+        if (e instanceof FileNotFoundException)
+            throw e;    // pass through 404 Not Found to allow the caller to handle it intelligently
+
+        InputStream es = wrapStream(uc, uc.getErrorStream());
+        try {
+            if (es!=null)
+                throw (IOException)new IOException(IOUtils.toString(es,"UTF-8")).initCause(e);
+            else
+                throw e;
+        } finally {
+            IOUtils.closeQuietly(es);
+        }
+    }
+
+    private Set<String> toSet(String s) {
+        Set<String> r = new HashSet<String>();
+        for (String t : s.split(","))
+            r.add(t.trim());
+        return r;
+    }
+}

src/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,36 @@
+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)`)
+
+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
+

src/test/java/Foo.java

@@ -0,0 +1,13 @@
+import org.kohsuke.github.GitHub;
+
+import java.util.Arrays;
+
+/**
+ * @author Kohsuke Kawaguchi
+ */
+public class Foo {
+    public static void main(String[] args) throws Exception {
+        System.out.println(GitHub.connect().createToken(
+                Arrays.asList("user", "repo", "delete_repo", "notifications", "gist"), "GitHub API", null).getToken());
+    }
+}

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

@@ -4,13 +4,17 @@ import junit.framework.TestCase;
 import org.kohsuke.github.GHCommit;
 import org.kohsuke.github.GHCommit.File;
 import org.kohsuke.github.GHCommitComment;
+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;
 import org.kohsuke.github.GHKey;
+import org.kohsuke.github.GHMilestone;
 import org.kohsuke.github.GHMyself;
 import org.kohsuke.github.GHOrganization;
 import org.kohsuke.github.GHOrganization.Permission;
@@ -20,7 +24,6 @@ import org.kohsuke.github.GHTeam;
 import org.kohsuke.github.GHUser;
 import org.kohsuke.github.GitHub;
 import org.kohsuke.github.PagedIterable;
-import org.kohsuke.github.PagedIterator;
 
 import java.io.IOException;
 import java.net.URL;
@@ -33,42 +36,68 @@ import java.util.List;
  * Unit test for simple App.
  */
 public class AppTest extends TestCase {
+
+    private GitHub gitHub;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        gitHub = GitHub.connect();
+    }
+
     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);
+        GHRepository r = gitHub.createRepository("github-api-test", "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();
+        gitHub.getMyself().getRepository("github-api-test2").delete();
     }
 
     public void testCredentialValid() throws IOException {
-        assertTrue(GitHub.connect().isCredentialValid());
-        assertFalse(GitHub.connect("totally","bogus").isCredentialValid());
+        assertTrue(gitHub.isCredentialValid());
+        assertFalse(GitHub.connect("totally", "bogus").isCredentialValid());
+    }
+
+    public void testIssueWithNoComment() throws IOException {
+        GHRepository repository = gitHub.getRepository("kohsuke/test");
+        List<GHIssueComment> v = repository.getIssue(4).getComments();
+        System.out.println(v);
+        assertTrue(v.isEmpty());
+
+        v = repository.getIssue(3).getComments();
+        System.out.println(v);
+        assertTrue(v.size() == 3);
+    }
+
+    public void testCreateIssue() throws IOException {
+        GHUser u = gitHub.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());
+        o.close();
     }
 
     public void testRateLimit() throws IOException {
-        System.out.println(GitHub.connect().getRateLimit());
+        System.out.println(gitHub.getRateLimit());
     }
 
     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);
     }
 
     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);
     }
 
     public void testFetchPullRequestAsList() throws Exception {
-        GitHub gh = GitHub.connect();
-        GHRepository r = gh.getOrganization("symfony").getRepository("symfony-docs");
+        GHRepository r = gitHub.getOrganization("symfony").getRepository("symfony-docs");
         assertEquals("master", r.getMasterBranch());
         PagedIterable<GHPullRequest> i = r.listPullRequests(GHIssueState.CLOSED);
         List<GHPullRequest> prs = i.asList();
@@ -77,19 +106,17 @@ public class AppTest extends TestCase {
     }
 
     public void testRepoPermissions() throws Exception {
-        GitHub gh = GitHub.connect();
-        GHRepository r = gh.getOrganization("jenkinsci").getRepository("jenkins");
+        GHRepository r = gitHub.getOrganization("jenkinsci").getRepository("jenkins");
         assertTrue(r.hasPullAccess());
 
-        r = gh.getOrganization("github").getRepository("tire");
+        r = gitHub.getOrganization("github").getRepository("tire");
         assertFalse(r.hasAdminAccess());
     }
     
-    public void tryGetMyself() throws Exception {
-        GitHub hub = GitHub.connect();
-        GHMyself me = hub.getMyself();
+    public void testGetMyself() throws Exception {
+        GHMyself me = gitHub.getMyself();
         System.out.println(me);
-        GHUser u = hub.getUser("kohsuke2");
+        GHUser u = gitHub.getUser("kohsuke2");
         System.out.println(u);
         for (List<GHRepository> lst : me.iterateRepositories(100)) {
             for (GHRepository r : lst) {
@@ -99,36 +126,30 @@ public class AppTest extends TestCase {
     }
 
     public void testPublicKeys() throws Exception {
-        GitHub gh = GitHub.connect();
-        List<GHKey> keys = gh.getMyself().getPublicKeys();
+        List<GHKey> keys = gitHub.getMyself().getPublicKeys();
         System.out.println(keys);
     }
 
     public void tryOrgFork() throws Exception {
-        GitHub gh = GitHub.connect();
-        gh.getUser("kohsuke").getRepository("rubywm").forkTo(gh.getOrganization("jenkinsci"));
+        gitHub.getUser("kohsuke").getRepository("rubywm").forkTo(gitHub.getOrganization("jenkinsci"));
     }
 
     public void tryGetTeamsForRepo() throws Exception {
-        GitHub gh = GitHub.connect();
-        Set<GHTeam> o = gh.getOrganization("jenkinsci").getRepository("rubywm").getTeams();
+        Set<GHTeam> o = gitHub.getOrganization("jenkinsci").getRepository("rubywm").getTeams();
         System.out.println(o);
     }
 
     public void testMembership() throws Exception {
-        GitHub gitHub = GitHub.connect();
         Set<String> members = gitHub.getOrganization("jenkinsci").getRepository("violations-plugin").getCollaboratorNames();
         System.out.println(members.contains("kohsuke"));
     }
     
     public void testMemberOrgs() throws Exception {
-        GitHub gitHub = GitHub.connect();
         Set<GHOrganization> o = gitHub.getUser("kohsuke").getOrganizations();
         System.out.println(o);
     }
 
     public void 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());
@@ -137,11 +158,10 @@ 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());
     }
 
     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());
@@ -152,14 +172,12 @@ public class AppTest extends TestCase {
     }
 
     public void testBranches() throws Exception {
-        GitHub gitHub = GitHub.connect();
         Map<String,GHBranch> b =
                 gitHub.getUser("jenkinsci").getRepository("jenkins").getBranches();
         System.out.println(b);
     }
 
     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();
@@ -170,7 +188,6 @@ public class AppTest extends TestCase {
     }
 
     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);
@@ -180,7 +197,6 @@ public class AppTest extends TestCase {
     }
 
     public void tryHook() throws Exception {
-        GitHub gitHub = GitHub.connect();
         GHRepository r = gitHub.getMyself().getRepository("test2");
         GHHook hook = r.createWebHook(new URL("http://www.google.com/"));
         System.out.println(hook);
@@ -190,7 +206,6 @@ public class AppTest extends TestCase {
     }
     
     public void testEventApi() throws Exception {
-        GitHub gitHub = GitHub.connect();
         for (GHEventInfo ev : gitHub.getEvents()) {
             System.out.println(ev);
             if (ev.getType()==GHEvent.PULL_REQUEST) {
@@ -202,10 +217,9 @@ public class AppTest extends TestCase {
     }
 
     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);
@@ -232,7 +246,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();
@@ -291,7 +305,6 @@ public class AppTest extends TestCase {
     }
 
     public void testOrgRepositories() throws IOException {
-        GitHub gitHub = GitHub.connect();
         GHOrganization j = gitHub.getOrganization("jenkinsci");
         long start = System.currentTimeMillis();
         Map<String, GHRepository> repos = j.getRepositories();
@@ -300,7 +313,6 @@ public class AppTest extends TestCase {
     }
     
     public void testOrganization() throws IOException {
-        GitHub gitHub = GitHub.connect();
         GHOrganization j = gitHub.getOrganization("jenkinsci");
         GHTeam t = j.getTeams().get("Core Developers");
 
@@ -308,4 +320,41 @@ public class AppTest extends TestCase {
 
 //        t.add(labs.getRepository("xyz"));
     }
+
+    public void testCommitStatus() throws Exception {
+        GHRepository r = gitHub.getUser("kohsuke").getRepository("test");
+        GHCommitStatus state;
+//        state = r.createCommitStatus("edacdd76b06c5f3f0697a22ca75803169f25f296", GHCommitState.FAILURE, "http://jenkins-ci.org/", "oops!");
+
+        List<GHCommitStatus> lst = r.listCommitStatuses("edacdd76b06c5f3f0697a22ca75803169f25f296").asList();
+        state = lst.get(0);
+        System.out.println(state);
+        assertEquals("oops!",state.getDescription());
+        assertEquals("http://jenkins-ci.org/",state.getTargetUrl());
+    }
+    
+    public void testCommitShortInfo() throws Exception {
+        GHCommit commit = gitHub.getUser("kohsuke").getRepository("test").getCommit("c77360d6f2ff2c2e6dd11828ad5dccf72419fa1b");
+        assertEquals(commit.getCommitShortInfo().getAuthor().getName(), "Kohsuke Kawaguchi");
+        assertEquals(commit.getCommitShortInfo().getMessage(), "Added a file");
+    }
+
+    public void testPullRequestPopulate() throws Exception {
+        GHRepository r = gitHub.getUser("kohsuke").getRepository("github-api");
+        GHPullRequest p = r.getPullRequest(17);
+        GHUser u = p.getUser();
+        assertNotNull(u.getName());
+    }
+
+    public void testCheckMembership() throws Exception {
+        GHOrganization j = gitHub.getOrganization("jenkinsci");
+        GHUser kohsuke = gitHub.getUser("kohsuke");
+        GHUser a = gitHub.getUser("a");
+
+        assertTrue(j.hasMember(kohsuke));
+        assertFalse(j.hasMember(a));
+
+        assertTrue(j.hasPublicMember(kohsuke));
+        assertFalse(j.hasPublicMember(a));
+    }
 }

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

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