/*package almost final*/ GitHub root;

private String description, homepage, name, full_name;

private String html_url; // this is the UI

/*

private GHLicense license;

private String git_url, ssh_url, clone_url, svn_url, mirror_url;

private GHUser owner; // not fully populated. beware.

private boolean has_issues, has_wiki, fork, has_downloads, has_pages, archived;

@JsonProperty("private")

private boolean _private;

private int forks_count, stargazers_count, watchers_count, size, open_issues_count, subscribers_count;

private String pushed_at;

private Map<Integer,GHMilestone> milestones = new WeakHashMap<Integer, GHMilestone>();

private String default_branch,language;

private Map<String,GHCommit> commits = new WeakHashMap<String, GHCommit>();

@SkipFromToString

private GHRepoPermission permissions;

private GHRepository source, parent;

public GHDeploymentBuilder createDeployment(String ref) {

return new GHDeploymentBuilder(this,ref);

}

/**

public PagedIterable<GHDeploymentStatus> getDeploymentStatuses(final int id) throws IOException {

return getDeployment(id).listStatuses();

}

public PagedIterable<GHDeployment> listDeployments(String sha,String ref,String task,String environment){

List<String> params = Arrays.asList(getParam("sha", sha), getParam("ref", ref), getParam("task", task), getParam("environment", environment));

final String deploymentsUrl = getApiTailUrl("deployments") + "?"+ join(params,"&");

return new PagedIterable<GHDeployment>() {

public PagedIterator<GHDeployment> _iterator(int pageSize) {

return new PagedIterator<GHDeployment>(root.retrieve().asIterator(deploymentsUrl, GHDeployment[].class, pageSize)) {

@Override

protected void wrapUp(GHDeployment[] page) {

for (GHDeployment c : page)

c.wrap(GHRepository.this);

}

};

}

};

}

/**

public GHDeployment getDeployment(long id) throws IOException {

return root.retrieve().to("deployments/" + id, GHDeployment.class).wrap(this);

}

private String join(List<String> params, String joinStr) {

StringBuilder output = new StringBuilder();

for(String param: params){

if(param != null){

output.append(param+joinStr);

}

}

return output.toString();

}

private String getParam(String name, String value) {

return StringUtils.trimToNull(value)== null? null: name+"="+value;

}

/**

public GHDeploymentStatusBuilder createDeployStatus(int deploymentId, GHDeploymentState ghDeploymentState) throws IOException {

return getDeployment(deploymentId).createStatus(ghDeploymentState);

}

private static class GHRepoPermission {

boolean pull,push,admin;

}

public String getDescription() {

return description;

}

public String getHomepage() {

return homepage;

}

/**

public String getGitTransportUrl() {

return git_url;

}

/**

public String getHttpTransportUrl() {

return clone_url;

}

/**

public String gitHttpTransportUrl() {

return clone_url;

}

/**

public String getSvnUrl() {

return svn_url;

}

/**

public String getMirrorUrl() {

return mirror_url;

}

/**

public String getSshUrl() {

return ssh_url;

}

public URL getHtmlUrl() {

return GitHub.parseURL(html_url);

}

/**

public String getName() {

return name;

}

/**

public String getFullName() {

return full_name;

}

public boolean hasPullAccess() {

return permissions!=null && permissions.pull;

}

public boolean hasPushAccess() {

return permissions!=null && permissions.push;

}

public boolean hasAdminAccess() {

return permissions!=null && permissions.admin;

}

/**

public String getLanguage() {

return language;

}

public GHUser getOwner() throws IOException {

return root.isOffline() ? owner : root.getUser(getOwnerName()); // because 'owner' isn't fully populated

}

public GHIssue getIssue(int id) throws IOException {

return root.retrieve().to(getApiTailUrl("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 listIssues(state).asList();

}

public List<GHIssue> getIssues(GHIssueState state, GHMilestone milestone) throws IOException {

return Arrays.asList(GHIssue.wrap(root.retrieve()

.with("state", state)

.with("milestone", milestone == null ? "none" : "" + milestone.getNumber())

.to(getApiTailUrl("issues"),

GHIssue[].class), this));

}

/**

public PagedIterable<GHIssue> listIssues(final GHIssueState state) {

return new PagedIterable<GHIssue>() {

public PagedIterator<GHIssue> _iterator(int pageSize) {

return new PagedIterator<GHIssue>(root.retrieve().with("state",state).asIterator(getApiTailUrl("issues"), GHIssue[].class, pageSize)) {

@Override

protected void wrapUp(GHIssue[] page) {

for (GHIssue c : page)

c.wrap(GHRepository.this);

}

};

}

};

}

public GHReleaseBuilder createRelease(String tag) {

return new GHReleaseBuilder(this,tag);

}

/**

public GHRef createRef(String name, String sha) throws IOException {

return new Requester(root)

.with("ref", name).with("sha", sha).method("POST").to(getApiTailUrl("git/refs"), GHRef.class).wrap(root);

}

/**

public List<GHRelease> getReleases() throws IOException {

return listReleases().asList();

}

public GHRelease getRelease(long id) throws IOException {

try {

return root.retrieve().to(getApiTailUrl("releases/" + id), GHRelease.class).wrap(this);

} catch (FileNotFoundException e) {

return null; // no release for this id

}

}

public GHRelease getReleaseByTagName(String tag) throws IOException {

try {

return root.retrieve().to(getApiTailUrl("releases/tags/" + tag), GHRelease.class).wrap(this);

} catch (FileNotFoundException e) {

return null; // no release for this tag

}

}

public GHRelease getLatestRelease() throws IOException {

try {

return root.retrieve().to(getApiTailUrl("releases/latest"), GHRelease.class).wrap(this);

} catch (FileNotFoundException e) {

return null; // no latest release

}

}

public PagedIterable<GHRelease> listReleases() throws IOException {

return new PagedIterable<GHRelease>() {

public PagedIterator<GHRelease> _iterator(int pageSize) {

return new PagedIterator<GHRelease>(root.retrieve().asIterator(getApiTailUrl("releases"), GHRelease[].class, pageSize)) {

@Override

protected void wrapUp(GHRelease[] page) {

for (GHRelease c : page)

c.wrap(GHRepository.this);

}

};

}

};

}

public PagedIterable<GHTag> listTags() throws IOException {

return new PagedIterable<GHTag>() {

public PagedIterator<GHTag> _iterator(int pageSize) {

return new PagedIterator<GHTag>(root.retrieve().asIterator(getApiTailUrl("tags"), GHTag[].class, pageSize)) {

@Override

protected void wrapUp(GHTag[] page) {

for (GHTag c : page)

c.wrap(GHRepository.this);

}

};

}

};

}

/**

public Map<String,Long> listLanguages() throws IOException {

return root.retrieve().to(getApiTailUrl("languages"), HashMap.class);

}

public String getOwnerName() {

// consistency of the GitHub API is super... some serialized forms of GHRepository populate

// a full GHUser while others populate only the owner and email. This later form is super helpful

// in putting the login in owner.name not owner.login... thankfully we can easily identify this

// second set because owner.login will be null

return owner.login != null ? owner.login : owner.name;

}

public boolean hasIssues() {

return has_issues;

}

public boolean hasWiki() {

return has_wiki;

}

public boolean isFork() {

return fork;

}

public boolean isArchived() {

return archived;

}

/**

public int getForks() {

return forks_count;

}

public int getStargazersCount() {

return stargazers_count;

}

public boolean isPrivate() {

return _private;

}

public boolean hasDownloads() {

return has_downloads;

}

public boolean hasPages() {

return has_pages;

}

public int getWatchers() {

return watchers_count;

}

public int getOpenIssueCount() {

return open_issues_count;

}

/**

public int getNetworkCount() {

return forks_count;

}

public int getSubscribersCount() {

return subscribers_count;

}

/**

public Date getPushedAt() {

return GitHub.parseDate(pushed_at);

}

/**

public String getDefaultBranch() {

return default_branch;

}

/**

public String getMasterBranch() {

return default_branch;

}

public int getSize() {

return size;

}

/**

@WithBridgeMethods(Set.class)

public GHPersonSet<GHUser> getCollaborators() throws IOException {

return new GHPersonSet<GHUser>(listCollaborators().asList());

}

/**

public PagedIterable<GHUser> listCollaborators() throws IOException {

return listUsers("collaborators");

}

/**

public PagedIterable<GHUser> listAssignees() throws IOException {

return listUsers("assignees");

}

/**

public boolean hasAssignee(GHUser u) throws IOException {

return root.retrieve().asHttpStatusCode(getApiTailUrl("assignees/" + u.getLogin()))/100==2;

}

/**

public Set<String> getCollaboratorNames() throws IOException {

Set<String> r = new HashSet<String>();

for (GHUser u : GHUser.wrap(root.retrieve().to(getApiTailUrl("collaborators"), GHUser[].class),root))

r.add(u.login);

return r;

}

/**

public GHPermissionType getPermission(String user) throws IOException {

GHPermission perm = root.retrieve().to(getApiTailUrl("collaborators/" + user + "/permission"), GHPermission.class);

perm.wrapUp(root);

return perm.getPermissionType();

}

/**

public GHPermissionType getPermission(GHUser u) throws IOException {

return getPermission(u.getLogin());

}

/**

public Set<GHTeam> getTeams() throws IOException {

return Collections.unmodifiableSet(new HashSet<GHTeam>(Arrays.asList(GHTeam.wrapUp(root.retrieve().to(getApiTailUrl("teams"), GHTeam[].class), root.getOrganization(getOwnerName())))));

}

public void addCollaborators(GHUser... users) throws IOException {

addCollaborators(asList(users));

}

public void addCollaborators(Collection<GHUser> users) throws IOException {

modifyCollaborators(users, "PUT");

}

public void removeCollaborators(GHUser... users) throws IOException {

removeCollaborators(asList(users));

}

public void removeCollaborators(Collection<GHUser> users) throws IOException {

modifyCollaborators(users, "DELETE");

}

private void modifyCollaborators(Collection<GHUser> users, String method) throws IOException {

for (GHUser user : users) {

new Requester(root).method(method).to(getApiTailUrl("collaborators/" + user.getLogin()));

}

}

public void setEmailServiceHook(String address) throws IOException {

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(getApiTailUrl("hooks"));

}

private void edit(String key, String value) throws IOException {

Requester requester = new Requester(root);

if (!key.equals("name"))

requester.with("name", name); // even when we don't change the name, we need to send it in

requester.with(key, value).method("PATCH").to(getApiTailUrl(""));

}

/**

public void enableIssueTracker(boolean v) throws IOException {

edit("has_issues", String.valueOf(v));

}

/**

public void enableWiki(boolean v) throws IOException {

edit("has_wiki", String.valueOf(v));

}

public void enableDownloads(boolean v) throws IOException {

edit("has_downloads",String.valueOf(v));

}

/**

public void renameTo(String name) throws IOException {

edit("name",name);

}

public void setDescription(String value) throws IOException {

edit("description",value);

}

public void setHomepage(String value) throws IOException {

edit("homepage",value);

}

public void setDefaultBranch(String value) throws IOException {

edit("default_branch", value);

}

/**

public void delete() throws IOException {

try {

new Requester(root).method("DELETE").to(getApiTailUrl(""));

} catch (FileNotFoundException x) {

throw (FileNotFoundException) new FileNotFoundException("Failed to delete " + getOwnerName() + "/" + name + "; might not exist, or you might need the delete_repo scope in your token: http://stackoverflow.com/a/19327004/12916").initCause(x);

}

}

/**

public enum ForkSort { NEWEST, OLDEST, STARGAZERS }

/**

public PagedIterable<GHRepository> listForks() {

return listForks(null);

}

/**

public PagedIterable<GHRepository> listForks(final ForkSort sort) {

return new PagedIterable<GHRepository>() {

public PagedIterator<GHRepository> _iterator(int pageSize) {

return new PagedIterator<GHRepository>(root.retrieve().with("sort",sort).asIterator(getApiTailUrl("forks"), GHRepository[].class, pageSize)) {

@Override

protected void wrapUp(GHRepository[] page) {

for (GHRepository c : page) {

c.wrap(root);

}

}

};

}

};

}

/**

public GHRepository fork() throws IOException {

new Requester(root).method("POST").to(getApiTailUrl("forks"), null);

// this API is asynchronous. we need to wait for a bit

for (int i=0; i<10; i++) {

GHRepository r = root.getMyself().getRepository(name);

if (r!=null) return r;

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

throw (IOException)new InterruptedIOException().initCause(e);

}

}

throw new IOException(this+" was forked but can't find the new repository");

}

/**

public GHRepository forkTo(GHOrganization org) throws IOException {

new Requester(root).to(getApiTailUrl("forks?org="+org.getLogin()));

// this API is asynchronous. we need to wait for a bit

for (int i=0; i<10; i++) {

GHRepository r = org.getRepository(name);

if (r!=null) return r;

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

throw (IOException)new InterruptedIOException().initCause(e);

}

}

throw new IOException(this+" was forked into "+org.getLogin()+" but can't find the new repository");

}

/**

public GHPullRequest getPullRequest(int i) throws IOException {

return root.retrieve().to(getApiTailUrl("pulls/" + i), GHPullRequest.class).wrapUp(this);

}

/**

public List<GHPullRequest> getPullRequests(GHIssueState state) throws IOException {

return queryPullRequests().state(state).list().asList();

}

/**

public PagedIterable<GHPullRequest> listPullRequests(GHIssueState state) {

return queryPullRequests().state(state).list();

}

/**

public GHPullRequestQueryBuilder queryPullRequests() {

return new GHPullRequestQueryBuilder(this);

}

/**

public GHPullRequest createPullRequest(String title, String head, String base, String body) throws IOException {

return createPullRequest(title, head, base, body, true);

}

/**

public GHPullRequest createPullRequest(String title, String head, String base, String body,

boolean maintainerCanModify) throws IOException {

return new Requester(root).with("title",title)

.with("head",head)

.with("base",base)

.with("body",body)

.with("maintainer_can_modify", maintainerCanModify)

.to(getApiTailUrl("pulls"),GHPullRequest.class)

.wrapUp(this);

}

/**

public List<GHHook> getHooks() throws IOException {

return GHHooks.repoContext(this, owner).getHooks();

}

public GHHook getHook(int id) throws IOException {

return GHHooks.repoContext(this, owner).getHook(id);

}

/**

public GHCompare getCompare(String id1, String id2) throws IOException {

GHCompare compare = root.retrieve().to(getApiTailUrl(String.format("compare/%s...%s", 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 {

GHRepository owner1 = id1.getOwner();

GHRepository owner2 = id2.getOwner();

// If the owner of the branches is different, we have a cross-fork compare.

if (owner1!=null && owner2!=null) {

String ownerName1 = owner1.getOwnerName();

String ownerName2 = owner2.getOwnerName();

if (!StringUtils.equals(ownerName1, ownerName2)) {

String qualifiedName1 = String.format("%s:%s", ownerName1, id1.getName());

String qualifiedName2 = String.format("%s:%s", ownerName2, id2.getName());

return getCompare(qualifiedName1, qualifiedName2);

}

}

return getCompare(id1.getName(), id2.getName());

}

/**

public GHRef[] getRefs() throws IOException {

return GHRef.wrap(root.retrieve().to(String.format("/repos/%s/%s/git/refs", getOwnerName(), name), GHRef[].class), root);

}

/**

public PagedIterable<GHRef> listRefs() throws IOException {

final String url = String.format("/repos/%s/%s/git/refs", getOwnerName(), name);

return new PagedIterable<GHRef>() {

public PagedIterator<GHRef> _iterator(int pageSize) {

return new PagedIterator<GHRef>(root.retrieve().asIterator(url, GHRef[].class, pageSize)) {

protected void wrapUp(GHRef[] page) {

for(GHRef p: page) {

p.wrap(root);

}

}

};

}

};

}

/**

public GHRef[] getRefs(String refType) throws IOException {

return GHRef.wrap(root.retrieve().to(String.format("/repos/%s/%s/git/refs/%s", getOwnerName(), name, refType), GHRef[].class),root);

}

/**

public PagedIterable<GHRef> listRefs(String refType) throws IOException {

final String url = String.format("/repos/%s/%s/git/refs/%s", getOwnerName(), name, refType);

return new PagedIterable<GHRef>() {

public PagedIterator<GHRef> _iterator(int pageSize) {

return new PagedIterator<GHRef>(root.retrieve().asIterator(url, GHRef[].class, pageSize)) {

protected void wrapUp(GHRef[] page) {

// no-op

}

};

}

};

}

/**

public GHRef getRef(String refName) throws IOException {

// hashes in branch names must be replaced with the url encoded equivalent or this call will fail

// FIXME: how about other URL unsafe characters, like space, @, : etc? do we need to be using URLEncoder.encode()?

// OTOH, '/' need no escaping

refName = refName.replaceAll("#", "%23");

return root.retrieve().to(String.format("/repos/%s/%s/git/refs/%s", getOwnerName(), name, refName), GHRef.class).wrap(root);

}

/**

public GHTagObject getTagObject(String sha) throws IOException {

return root.retrieve().to(getApiTailUrl("git/tags/" + sha), GHTagObject.class).wrap(this);

}

/**

public GHTree getTree(String sha) throws IOException {

String url = String.format("/repos/%s/%s/git/trees/%s", getOwnerName(), name, sha);

return root.retrieve().to(url, GHTree.class).wrap(this);

}

public GHTreeBuilder createTree() {

return new GHTreeBuilder(this);

}

/**

public GHTree getTreeRecursive(String sha, int recursive) throws IOException {

String url = String.format("/repos/%s/%s/git/trees/%s?recursive=%d", getOwnerName(), name, sha, recursive);

return root.retrieve().to(url, GHTree.class).wrap(this);

}

/**

public GHBlob getBlob(String blobSha) throws IOException {

String target = getApiTailUrl("git/blobs/" + blobSha);

return root.retrieve().to(target, GHBlob.class);

}

public GHBlobBuilder createBlob() {

return new GHBlobBuilder(this);

}

/**

public InputStream readBlob(String blobSha) throws IOException {

String target = getApiTailUrl("git/blobs/" + blobSha);

return root.retrieve().withHeader("Accept","application/vnd.github.VERSION.raw").asStream(target);

}

/**

public GHCommit getCommit(String sha1) throws IOException {

GHCommit c = commits.get(sha1);

if (c==null) {

c = root.retrieve().to(String.format("/repos/%s/%s/commits/%s", getOwnerName(), name, sha1), GHCommit.class).wrapUp(this);

commits.put(sha1,c);