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

Allow oauthToken to be used without login

.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>4</version>
   </parent>
 
   <artifactId>github-api</artifactId>
-  <version>1.34</version>
+  <version>1.42</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>

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

@@ -138,7 +138,7 @@ public class GHIssue {
      * Updates the issue by adding a comment.
      */
     public void comment(String message) throws IOException {
-        new Requester(root).with("body",message).to(getApiRoute() + "/comments");
+        new Requester(root).with("body",message).to(getIssuesApiRoute() + "/comments");
     }
 
     private void edit(String key, Object value) throws IOException {
@@ -190,7 +190,7 @@ public class GHIssue {
     public PagedIterable<GHIssueComment> listComments() throws IOException {
         return new PagedIterable<GHIssueComment>() {
             public PagedIterator<GHIssueComment> iterator() {
-                return new PagedIterator<GHIssueComment>(root.retrieve().asIterator(getApiRoute() + "/comments", GHIssueComment[].class)) {
+                return new PagedIterator<GHIssueComment>(root.retrieve().asIterator(getIssuesApiRoute() + "/comments", GHIssueComment[].class)) {
                     protected void wrapUp(GHIssueComment[] page) {
                         for (GHIssueComment c : page)
                             c.wrapUp(GHIssue.this);
@@ -200,7 +200,11 @@ public class GHIssue {
         };
     }
 
-    private String getApiRoute() {
+    protected String getApiRoute() {
+        return getIssuesApiRoute();
+    }
+
+    private String getIssuesApiRoute() {
         return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/issues/"+number;
     }
 
@@ -250,4 +254,4 @@ public class GHIssue {
 			return GitHub.parseURL(html_url);
 		}
 	}
-}
+}

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;
@@ -50,6 +46,30 @@ 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.
      */
@@ -112,13 +132,13 @@ public class GHOrganization extends GHPerson {
      * List up repositories that has some open pull requests.
      */
     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 : root.retrieve().to("/orgs/" + login + "/repos", GHRepository[].class)) {
+            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/GHPullRequest.java

@@ -63,7 +63,12 @@ public class GHPullRequest extends GHIssue {
         if (merged_by != null) merged_by.wrapUp(root);
         return this;
     }
-	
+
+    @Override
+    protected String getApiRoute() {
+        return "/repos/"+owner.getOwnerName()+"/"+owner.getName()+"/pulls/"+number;
+    }
+
     /**
      * The URL of the patch file.
      * like https://github.com/jenkinsci/jenkins/pull/100.patch

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;
@@ -266,15 +260,10 @@ public class GHRepository {
     }
 
     public void setEmailServiceHook(String address) throws IOException {
-        WebClient wc = root.createWebClient();
-        HtmlPage pg = (HtmlPage)wc.getPage(getUrl()+"/admin");
-        HtmlInput email = (HtmlInput)pg.getElementById("email_address");
-        email.setValueAttribute(address);
-        HtmlCheckBoxInput active = (HtmlCheckBoxInput)pg.getElementById("email[active]");
-        active.setChecked(true);
-
-        final HtmlForm f = email.getEnclosingFormOrDie();
-        f.submit((HtmlButton) f.getElementsByTagName("button").get(0));
+        Map<String, String> config = new HashMap<String, String>();
+        config.put("address", address);
+        new Requester(root).method("POST").with("name", "email").with("config", config).with("active", "true")
+                .to(String.format("/repos/%s/%s/hooks", owner.login, name));
     }
 
     private void edit(String key, String value) throws IOException {
@@ -404,6 +393,46 @@ public class GHRepository {
         return root.retrieve().to(String.format("/repos/%s/%s/hooks/%d", owner.login, name, id), GHHook.class).wrap(this);
     }
 
+    /**
+     * Gets a comparison between 2 points in the repository. This would be similar
+     * to calling <tt>git log id1...id2</tt> against a local repository.
+     * @param id1 an identifier for the first point to compare from, this can be a sha1 ID (for a commit, tag etc) or a direct tag name
+     * @param id2 an identifier for the second point to compare to. Can be the same as the first point.
+     * @return the comparison output
+     * @throws IOException on failure communicating with GitHub
+     */
+    public GHCompare getCompare(String id1, String id2) throws IOException {
+        GHCompare compare = root.retrieve().to(String.format("/repos/%s/%s/compare/%s...%s", owner.login, name, id1, id2), GHCompare.class);
+        return compare.wrap(this);
+    }
+
+    public GHCompare getCompare(GHCommit id1, GHCommit id2) throws IOException {
+        return getCompare(id1.getSHA1(),id2.getSHA1());
+    }
+
+    public GHCompare getCompare(GHBranch id1, GHBranch id2) throws IOException {
+        return getCompare(id1.getName(),id2.getName());
+    }
+
+    /**
+     * Retrieves all refs for the github repository.
+     * @return an array of GHRef elements coresponding with the refs in the remote repository.
+     * @throws IOException on failure communicating with GitHub
+     */
+    public GHRef[] getRefs() throws IOException {
+       return root.retrieve().to(String.format("/repos/%s/%s/git/refs", owner.login, name), GHRef[].class);
+    }
+
+    /**
+     * Retrienved all refs of the given type for the current GitHub repository.
+     * @param refType the type of reg to search for e.g. <tt>tags</tt> or <tt>commits</tt>
+     * @return an array of all refs matching the request type
+     * @throws IOException on failure communicating with GitHub, potentially due to an invalid ref type being requested
+     */
+    public GHRef[] getRefs(String refType) throws IOException {
+        return root.retrieve().to(String.format("/repos/%s/%s/git/refs/%s", owner.login, name, refType), GHRef[].class);
+    }
+
     /**
      * Gets a commit object in this repository.
      */

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

@@ -69,6 +69,20 @@ public class GHUser extends GHPerson {
         return new GHPersonSet<GHUser>(Arrays.asList(wrap(followers,root)));
     }
 
+    /**
+     * Returns true if this user belongs to the specified organization.
+     */
+    public boolean isMemberOf(GHOrganization org) {
+        return org.hasMember(this);
+    }
+
+    /**
+     * Returns true if this user belongs to the specified 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;

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

@@ -23,15 +23,12 @@
  */
 package org.kohsuke.github;
 
-import com.gargoylesoftware.htmlunit.WebClient;
-import com.gargoylesoftware.htmlunit.html.HtmlForm;
-import com.gargoylesoftware.htmlunit.html.HtmlPage;
 import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
+import org.apache.commons.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;
@@ -42,6 +39,7 @@ import java.net.URL;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
@@ -58,54 +56,78 @@ import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.*;
  */
 public class GitHub {
     /*package*/ final String login;
+
+    /**
+     * Value of the authorization header to be sent with the request.
+     */
     /*package*/ final String encodedAuthorization;
-    /*package*/ final String password;
-    /*package*/ final String apiToken;
 
     private final Map<String,GHUser> users = new HashMap<String, GHUser>();
     private final Map<String,GHOrganization> orgs = new HashMap<String, GHOrganization>();
-	/*package*/ String oauthAccessToken;
-	
-	private final String apiUrl;
 
-	private GitHub(String login, String apiToken, String password) {
-		this ("https://api.github.com", login, apiToken, password);
-	}
+    private final String apiUrl;
 
     /**
+     * Connects to GitHub.com
+     */
+    private GitHub(String login, String oauthAccessToken, String password) throws IOException {
+      this (GITHUB_URL, login, oauthAccessToken, password);
+    }
+
+    /**
+     * Creates a client API root object.
+     *
+     * <p>
+     * Several different combinations of the login/oauthAccessToken/password parameters are allowed
+     * to represent different ways of authentication.
+     *
+     * <dl>
+     *     <dt>Loging anonymously
+     *     <dd>Leave all three parameters null and you will be making HTTP requests without any authentication.
+     *
+     *     <dt>Log in with password
+     *     <dd>Specify the login and password, then leave oauthAccessToken null.
+     *         This will use the HTTP BASIC auth with the GitHub API.
+     *
+     *     <dt>Log in with OAuth token
+     *     <dd>Specify oauthAccessToken, and optionally specify the login. Leave password null.
+     *         This will send OAuth token to the GitHub API. If the login parameter is null,
+     *         The constructor makes an API call to figure out the user name that owns the token.
+     * </dl>
      *
      * @param apiUrl
      *      The URL of GitHub (or GitHub enterprise) API endpoint, such as "https://api.github.com" or
      *      "http://ghe.acme.com/api/v3". Note that GitHub Enterprise has <tt>/api/v3</tt> in the URL.
      *      For historical reasons, this parameter still accepts the bare domain name, but that's considered deprecated.
+     *      Password is also considered deprecated as it is no longer required for api usage.
+     * @param login
+     *      The use ID on GitHub that you are logging in as. Can be omitted if the OAuth token is
+     *      provided or if logging in anonymously. Specifying this would save one API call.
+     * @param oauthAccessToken
+     *      Secret OAuth token.
+     * @param password
+     *      User's password. Always used in conjunction with the {@code login} parameter
      */
-    private GitHub(String apiUrl, String login, String apiToken, String password) {
+    private GitHub(String apiUrl, String login, String oauthAccessToken, String password) throws IOException {
         if (apiUrl.endsWith("/")) apiUrl = apiUrl.substring(0, apiUrl.length()-1); // normalize
         this.apiUrl = apiUrl;
-		this.login = login;
-        this.apiToken = apiToken;
-        this.password = password;
 
-        BASE64Encoder enc = new sun.misc.BASE64Encoder();
-        if (apiToken!=null || password!=null) {
-            String userpassword = password==null ? (login + "/token" + ":" + apiToken) : (login + ':'+password);
-            encodedAuthorization = enc.encode(userpassword.getBytes());
-        } else
-            encodedAuthorization = null;
+        if (oauthAccessToken!=null) {
+            encodedAuthorization = "token "+oauthAccessToken;
+        } else {
+            if (password!=null) {
+                String authorization = (login + ':' + password);
+                encodedAuthorization = "Basic "+new String(Base64.encodeBase64(authorization.getBytes()));
+            } else {// anonymous access
+                encodedAuthorization = null;
+            }
+        }
+
+        if (login==null)
+            login = getMyself().getLogin();
+        this.login = login;
     }
 
-    private GitHub (String apiUrl, String oauthAccessToken) throws IOException {
-    	
-		this.apiUrl = apiUrl;
-		this.password = null;
-		this.encodedAuthorization = null;
-		
-		this.oauthAccessToken = oauthAccessToken;
-        this.apiToken = oauthAccessToken;
-		
-		this.login = getMyself().getLogin();
-    }
-    
     /**
      * Obtains the credential from "~/.github"
      */
@@ -118,7 +140,7 @@ public class GitHub {
         } finally {
             IOUtils.closeQuietly(in);
         }
-        return new GitHub(props.getProperty("login"),props.getProperty("token"),props.getProperty("password"));
+        return new GitHub(GITHUB_URL,props.getProperty("login"), props.getProperty("oauth"),props.getProperty("password"));
     }
 
     /**
@@ -129,51 +151,56 @@ public class GitHub {
      *      "http://ghe.acme.com/api/v3". Note that GitHub Enterprise has <tt>/api/v3</tt> in the URL.
      *      For historical reasons, this parameter still accepts the bare domain name, but that's considered deprecated.
      */
-    public static GitHub connectToEnterprise(String apiUrl, String login, String apiToken) {
-        // not exposing password because the login process still assumes https://github.com/
-        // if we are to fix this, fix that by getting rid of createWebClient() and replace the e-mail service hook
-        // with GitHub API.
-        return new GitHub(apiUrl,login,apiToken,null);
+    public static GitHub connectToEnterprise(String apiUrl, String oauthAccessToken) throws IOException {
+        return connectUsingOAuth(apiUrl, oauthAccessToken);
     }
 
-    public static GitHub connect(String login, String apiToken){
-        return new GitHub(login,apiToken,null);
+    public static GitHub connectToEnterprise(String apiUrl, String login, String password) throws IOException {
+        return new GitHub(apiUrl, login, null, password);
     }
 
-    public static GitHub connect(String login, String apiToken, String password){
-        return new GitHub(login,apiToken,password);
+    public static GitHub connect(String login, String oauthAccessToken) throws IOException {
+        return new GitHub(login,oauthAccessToken,null);
     }
 
-    public static GitHub connectUsingOAuth (String accessToken) throws IOException {
-    	return connectUsingOAuth("github.com", accessToken);
+    /**
+     * @deprecated
+     *      Either OAuth token or password is sufficient, so there's no point in passing both.
+     *      Use {@link #connectUsingPassword(String, String)} or {@link #connectUsingOAuth(String)}.
+     */
+    public static GitHub connect(String login, String oauthAccessToken, String password) throws IOException {
+        return new GitHub(login,oauthAccessToken,password);
     }
-    
-    public static GitHub connectUsingOAuth (String githubServer, String accessToken) throws IOException {
-    	return new GitHub(githubServer, accessToken);
+
+    public static GitHub connectUsingPassword(String login, String password) throws IOException {
+        return new GitHub(login,null,password);
+    }
+
+    public static GitHub connectUsingOAuth(String oauthAccessToken) throws IOException {
+    	return new GitHub(null, oauthAccessToken, null);
+    }
+
+    public static GitHub connectUsingOAuth(String githubServer, String oauthAccessToken) throws IOException {
+    	return new GitHub(githubServer,null, oauthAccessToken,null);
     }
     /**
      * Connects to GitHub anonymously.
      *
      * All operations that requires authentication will fail.
      */
-    public static GitHub connectAnonymously() {
+    public static GitHub connectAnonymously() throws IOException {
         return new GitHub(null,null,null);
     }
 
     /*package*/ void requireCredential() {
-        if ((login==null || encodedAuthorization==null) && oauthAccessToken == null)
+        if (login==null && encodedAuthorization==null)
             throw new IllegalStateException("This operation requires a credential but none is given to the GitHub constructor");
     }
 
     /*package*/ URL getApiURL(String tailApiUrl) throws IOException {
-    	if (oauthAccessToken != null) {
-    		// append the access token
-    		tailApiUrl = tailApiUrl +  (tailApiUrl.indexOf('?')>=0 ?'&':'?') + "access_token=" + oauthAccessToken;
-    	}
-
         if (tailApiUrl.startsWith("/")) {
             if ("github.com".equals(apiUrl)) {// backward compatibility
-                return new URL("https://api.github.com" + tailApiUrl);
+                return new URL(GITHUB_URL + tailApiUrl);
             } else {
                 return new URL(apiUrl + tailApiUrl);
             }
@@ -273,7 +300,7 @@ public class GitHub {
      * Public events visible to you. Equivalent of what's displayed on https://github.com/
      */
     public List<GHEventInfo> getEvents() throws IOException {
-        // TODO: pagenation
+        // TODO: pagination
         GHEventInfo[] events = retrieve().to("/events", GHEventInfo[].class);
         for (GHEventInfo e : events)
             e.wrapUp(this);
@@ -292,7 +319,7 @@ public class GitHub {
         t.wrapUp(this);
         return t;
     }
-    
+
     /**
      * Creates a new repository.
      *
@@ -306,6 +333,22 @@ public class GitHub {
         return requester.method("POST").to("/user/repos", GHRepository.class).wrap(this);
     }
 
+    /**
+     * Creates a new authorization.
+     *
+     * The token created can be then used for {@link GitHub#connectUsingOAuth(String)} in the future.
+     *
+     * @see <a href="http://developer.github.com/v3/oauth/#create-a-new-authorization">Documentation</a>
+     */
+	public GHAuthorization createToken(Collection<String> scope, String note, String noteUrl) throws IOException{
+		Requester requester = new Requester(this)
+				.with("scopes", scope)
+				.with("note", note)
+				.with("note_url", noteUrl);
+
+		return requester.method("POST").to("/authorizations", GHAuthorization.class).wrap(this);
+	}
+
     /**
      * Ensures that the credential is valid.
      */
@@ -318,18 +361,6 @@ public class GitHub {
         }
     }
 
-    WebClient createWebClient() throws IOException {
-        WebClient wc = new WebClient();
-        wc.setJavaScriptEnabled(false);
-        wc.setCssEnabled(false);
-        HtmlPage pg = (HtmlPage)wc.getPage("https://github.com/login");
-        HtmlForm f = pg.getForms().get(0);
-        f.getInputByName("login").setValueAttribute(login);
-        f.getInputByName("password").setValueAttribute(password);
-        f.submit();
-        return wc;
-    }
-
     /*package*/ static URL parseURL(String s) {
         try {
             return s==null ? null : new URL(s);
@@ -360,4 +391,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/Requester.java

@@ -39,10 +39,12 @@ 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.*;
@@ -107,6 +109,10 @@ class Requester {
         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));
@@ -267,9 +273,8 @@ class Requester {
 
         // if the authentication is needed but no credential is given, try it anyway (so that some calls
         // that do work with anonymous access in the reduced form should still work.)
-        // if OAuth token is present, it'll be set in the URL, so need to set the Authorization header
-        if (root.encodedAuthorization!=null && root.oauthAccessToken == null)
-            uc.setRequestProperty("Authorization", "Basic " + root.encodedAuthorization);
+        if (root.encodedAuthorization!=null)
+            uc.setRequestProperty("Authorization", root.encodedAuthorization);
 
         try {
             uc.setRequestMethod(method);
@@ -341,4 +346,11 @@ class Requester {
             IOUtils.closeQuietly(es);
         }
     }
+
+    private Set<String> toSet(String s) {
+        Set<String> r = new HashSet<String>();
+        for (String t : s.split(","))
+            r.add(t.trim());
+        return r;
+    }
 }

src/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

@@ -36,34 +36,42 @@ 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());
+        assertTrue(gitHub.isCredentialValid());
         assertFalse(GitHub.connect("totally", "bogus").isCredentialValid());
     }
 
     public void testIssueWithNoComment() throws IOException {
-        GHRepository repository = GitHub.connect().getRepository("kohsuke/test");
+        GHRepository repository = gitHub.getRepository("kohsuke/test");
         List<GHIssueComment> v = repository.getIssue(4).getComments();
         System.out.println(v);
         assertTrue(v.isEmpty());
 
         v = repository.getIssue(3).getComments();
         System.out.println(v);
-        assertTrue(v.size()==3);
+        assertTrue(v.size() == 3);
     }
 
     public void testCreateIssue() throws IOException {
-        GHUser u = GitHub.connect().getUser("kohsuke");
+        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();
@@ -72,26 +80,24 @@ public class AppTest extends TestCase {
     }
 
     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();
@@ -100,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 testGetMyself() throws Exception {
-        GitHub hub = GitHub.connect();
-        GHMyself me = hub.getMyself();
+        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) {
@@ -122,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());
@@ -160,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());
@@ -175,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();
@@ -193,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);
@@ -203,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);
@@ -213,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) {
@@ -225,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);
@@ -255,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();
@@ -314,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();
@@ -323,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");
 
@@ -333,7 +322,6 @@ public class AppTest extends TestCase {
     }
 
     public void testCommitStatus() throws Exception {
-        GitHub gitHub = GitHub.connect();
         GHRepository r = gitHub.getUser("kohsuke").getRepository("test");
         GHCommitStatus state;
 //        state = r.createCommitStatus("edacdd76b06c5f3f0697a22ca75803169f25f296", GHCommitState.FAILURE, "http://jenkins-ci.org/", "oops!");
@@ -346,10 +334,21 @@ public class AppTest extends TestCase {
     }
 
     public void testPullRequestPopulate() throws Exception {
-        GitHub gitHub = GitHub.connect();
         GHRepository r = gitHub.getUser("kohsuke").getRepository("github-api");
         GHPullRequest p = r.getPullRequest(17);
         GHUser u = p.getUser();
         assertNotNull(u.getName());
     }
+
+    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

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