jlengrand/github-api
1
0
Fork 0
mirror of https://github.com/jlengrand/github-api.git synced 2026-03-23 08:21:22 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
bcde8596e946509967e9bc82c57d79b06d6d6336
github-api/jacoco/org.kohsuke.github/GHRepository.java.html
Liam Newman bcde8596e9 Release v1.127
2021-04-09 09:01:58 -07:00

3257 lines
126 KiB
HTML
Raw Blame History

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml" lang="en"><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/><link rel="stylesheet" href="../jacoco-resources/report.css" type="text/css"/><link rel="shortcut icon" href="../jacoco-resources/report.gif" type="image/gif"/><title>GHRepository.java</title><link rel="stylesheet" href="../jacoco-resources/prettify.css" type="text/css"/><script type="text/javascript" src="../jacoco-resources/prettify.js"></script></head><body onload="window['PR_TAB_WIDTH']=4;prettyPrint()"><div class="breadcrumb" id="breadcrumb"><span class="info"><a href="../jacoco-sessions.html" class="el_session">Sessions</a></span><a href="../index.html" class="el_report">GitHub API for Java</a> &gt; <a href="index.source.html" class="el_package">org.kohsuke.github</a> &gt; <span class="el_source">GHRepository.java</span></div><h1>GHRepository.java</h1><pre class="source lang-java linenums">/*
* 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 &quot;Software&quot;), 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 &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.github;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonParseException;
import com.infradna.tool.bridge_method_injector.WithBridgeMethods;
import edu.umd.cs.findbugs.annotations.CheckForNull;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.apache.commons.lang3.StringUtils;
import org.kohsuke.github.function.InputStreamFunction;
import org.kohsuke.github.internal.EnumUtils;
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.URL;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.WeakHashMap;
import javax.annotation.Nonnull;
import static java.util.Arrays.asList;
import static java.util.Objects.requireNonNull;
import static org.kohsuke.github.internal.Previews.ANTIOPE;
import static org.kohsuke.github.internal.Previews.ANT_MAN;
import static org.kohsuke.github.internal.Previews.BAPTISTE;
import static org.kohsuke.github.internal.Previews.FLASH;
import static org.kohsuke.github.internal.Previews.INERTIA;
import static org.kohsuke.github.internal.Previews.MERCY;
import static org.kohsuke.github.internal.Previews.NEBULA;
import static org.kohsuke.github.internal.Previews.SHADOW_CAT;
/**
* A repository on GitHub.
*
* @author Kohsuke Kawaguchi
*/
@SuppressWarnings({ &quot;UnusedDeclaration&quot; })
@SuppressFBWarnings(value = { &quot;UWF_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD&quot;, &quot;UWF_UNWRITTEN_FIELD&quot;, &quot;NP_UNWRITTEN_FIELD&quot; },
justification = &quot;JSON API&quot;)
<span class="fc" id="L80">public class GHRepository extends GHObject {</span>
private String nodeId, description, homepage, name, full_name;
private String html_url; // this is the UI
/*
* The license information makes use of the preview API.
*
* See: https://developer.github.com/v3/licenses/
*/
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, has_projects;
private boolean allow_squash_merge;
private boolean allow_merge_commit;
private boolean allow_rebase_merge;
private boolean delete_branch_on_merge;
@JsonProperty(&quot;private&quot;)
private boolean _private;
private String visibility;
private int forks_count, stargazers_count, watchers_count, size, open_issues_count, subscribers_count;
private String pushed_at;
<span class="fc" id="L116"> private Map&lt;Integer, GHMilestone&gt; milestones = new WeakHashMap&lt;Integer, GHMilestone&gt;();</span>
private String default_branch, language;
<span class="fc" id="L120"> private Map&lt;String, GHCommit&gt; commits = new WeakHashMap&lt;String, GHCommit&gt;();</span>
@SkipFromToString
private GHRepoPermission permissions;
private GHRepository source, parent;
private Boolean isTemplate;
static GHRepository read(GitHub root, String owner, String name) throws IOException {
<span class="fc" id="L130"> return root.createRequest().withUrlPath(&quot;/repos/&quot; + owner + '/' + name).fetch(GHRepository.class).wrap(root);</span>
}
/**
* Create deployment gh deployment builder.
*
* @param ref
* the ref
* @return the gh deployment builder
*/
public GHDeploymentBuilder createDeployment(String ref) {
<span class="fc" id="L141"> return new GHDeploymentBuilder(this, ref);</span>
}
/**
* Gets deployment statuses.
*
* @param id
* the id
* @return the deployment statuses
* @throws IOException
* the io exception
* @deprecated Use {@code getDeployment(id).listStatuses()}
*/
@Deprecated
public PagedIterable&lt;GHDeploymentStatus&gt; getDeploymentStatuses(final int id) throws IOException {
<span class="nc" id="L156"> return getDeployment(id).listStatuses();</span>
}
/**
* List deployments paged iterable.
*
* @param sha
* the sha
* @param ref
* the ref
* @param task
* the task
* @param environment
* the environment
* @return the paged iterable
*/
public PagedIterable&lt;GHDeployment&gt; listDeployments(String sha, String ref, String task, String environment) {
<span class="fc" id="L173"> return root.createRequest()</span>
<span class="fc" id="L174"> .with(&quot;sha&quot;, sha)</span>
<span class="fc" id="L175"> .with(&quot;ref&quot;, ref)</span>
<span class="fc" id="L176"> .with(&quot;task&quot;, task)</span>
<span class="fc" id="L177"> .with(&quot;environment&quot;, environment)</span>
<span class="fc" id="L178"> .withUrlPath(getApiTailUrl(&quot;deployments&quot;))</span>
<span class="fc" id="L179"> .withPreview(ANT_MAN)</span>
<span class="fc" id="L180"> .withPreview(FLASH)</span>
<span class="fc" id="L181"> .toIterable(GHDeployment[].class, item -&gt; item.wrap(this));</span>
}
/**
* Obtains a single {@link GHDeployment} by its ID.
*
* @param id
* the id
* @return the deployment
* @throws IOException
* the io exception
*/
public GHDeployment getDeployment(long id) throws IOException {
<span class="fc" id="L194"> return root.createRequest()</span>
<span class="fc" id="L195"> .withUrlPath(getApiTailUrl(&quot;deployments/&quot; + id))</span>
<span class="fc" id="L196"> .withPreview(ANT_MAN)</span>
<span class="fc" id="L197"> .withPreview(FLASH)</span>
<span class="fc" id="L198"> .fetch(GHDeployment.class)</span>
<span class="fc" id="L199"> .wrap(this);</span>
}
/**
* Gets deploy status.
*
* @param deploymentId
* the deployment id
* @param ghDeploymentState
* the gh deployment state
* @return the deploy status
* @throws IOException
* the io exception
* @deprecated Use {@code getDeployment(deploymentId).createStatus(ghDeploymentState)}
*/
@Deprecated
public GHDeploymentStatusBuilder createDeployStatus(int deploymentId, GHDeploymentState ghDeploymentState)
throws IOException {
<span class="nc" id="L217"> return getDeployment(deploymentId).createStatus(ghDeploymentState);</span>
}
private static class GHRepoPermission {
boolean pull, push, admin;
}
/**
* Gets node id
*
* @return the node id
*/
public String getNodeId() {
<span class="fc" id="L230"> return nodeId;</span>
}
/**
* Gets description.
*
* @return the description
*/
public String getDescription() {
<span class="fc" id="L239"> return description;</span>
}
/**
* Gets homepage.
*
* @return the homepage
*/
public String getHomepage() {
<span class="fc" id="L248"> return homepage;</span>
}
/**
* Gets the git:// URL to this repository, such as &quot;git://github.com/kohsuke/jenkins.git&quot; This URL is read-only.
*
* @return the git transport url
*/
public String getGitTransportUrl() {
<span class="nc" id="L257"> return git_url;</span>
}
/**
* Gets the HTTPS URL to this repository, such as &quot;https://github.com/kohsuke/jenkins.git&quot; This URL is read-only.
*
* @return the http transport url
*/
public String getHttpTransportUrl() {
<span class="fc" id="L266"> return clone_url;</span>
}
/**
* Git http transport url string.
*
* @return the string
* @deprecated Typo of {@link #getHttpTransportUrl()}
*/
@Deprecated
public String gitHttpTransportUrl() {
<span class="fc" id="L277"> return clone_url;</span>
}
/**
* Gets the Subversion URL to access this repository: https://github.com/rails/rails
*
* @return the svn url
*/
public String getSvnUrl() {
<span class="nc" id="L286"> return svn_url;</span>
}
/**
* Gets the Mirror URL to access this repository: https://github.com/apache/tomee mirrored from
* git://git.apache.org/tomee.git
*
* @return the mirror url
*/
public String getMirrorUrl() {
<span class="nc" id="L296"> return mirror_url;</span>
}
/**
* Gets the SSH URL to access this repository, such as git@github.com:rails/rails.git
*
* @return the ssh url
*/
public String getSshUrl() {
<span class="nc" id="L305"> return ssh_url;</span>
}
public URL getHtmlUrl() {
<span class="nc" id="L309"> return GitHubClient.parseURL(html_url);</span>
}
/**
* Short repository name without the owner. For example 'jenkins' in case of http://github.com/jenkinsci/jenkins
*
* @return the name
*/
public String getName() {
<span class="fc" id="L318"> return name;</span>
}
/**
* Full repository name including the owner or organization. For example 'jenkinsci/jenkins' in case of
* http://github.com/jenkinsci/jenkins
*
* @return the full name
*/
public String getFullName() {
<span class="fc" id="L328"> return full_name;</span>
}
/**
* Has pull access boolean.
*
* @return the boolean
*/
public boolean hasPullAccess() {
<span class="pc bpc" id="L337" title="2 of 4 branches missed."> return permissions != null &amp;&amp; permissions.pull;</span>
}
/**
* Has push access boolean.
*
* @return the boolean
*/
public boolean hasPushAccess() {
<span class="pc bpc" id="L346" title="2 of 4 branches missed."> return permissions != null &amp;&amp; permissions.push;</span>
}
/**
* Has admin access boolean.
*
* @return the boolean
*/
public boolean hasAdminAccess() {
<span class="pc bpc" id="L355" title="2 of 4 branches missed."> return permissions != null &amp;&amp; permissions.admin;</span>
}
/**
* Gets the primary programming language.
*
* @return the language
*/
public String getLanguage() {
<span class="fc" id="L364"> return language;</span>
}
/**
* Gets owner.
*
* @return the owner
* @throws IOException
* the io exception
*/
public GHUser getOwner() throws IOException {
<span class="fc bfc" id="L375" title="All 2 branches covered."> return root.isOffline() ? owner : root.getUser(getOwnerName()); // because 'owner' isn't fully populated</span>
}
/**
* Gets issue.
*
* @param id
* the id
* @return the issue
* @throws IOException
* the io exception
*/
public GHIssue getIssue(int id) throws IOException {
<span class="fc" id="L388"> return root.createRequest().withUrlPath(getApiTailUrl(&quot;issues/&quot; + id)).fetch(GHIssue.class).wrap(this);</span>
}
/**
* Create issue gh issue builder.
*
* @param title
* the title
* @return the gh issue builder
*/
public GHIssueBuilder createIssue(String title) {
<span class="fc" id="L399"> return new GHIssueBuilder(this, title);</span>
}
/**
* Gets issues.
*
* @param state
* the state
* @return the issues
* @throws IOException
* the io exception
*/
public List&lt;GHIssue&gt; getIssues(GHIssueState state) throws IOException {
<span class="fc" id="L412"> return listIssues(state).toList();</span>
}
/**
* Gets issues.
*
* @param state
* the state
* @param milestone
* the milestone
* @return the issues
* @throws IOException
* the io exception
*/
public List&lt;GHIssue&gt; getIssues(GHIssueState state, GHMilestone milestone) throws IOException {
<span class="nc" id="L427"> Requester requester = root.createRequest()</span>
<span class="nc" id="L428"> .with(&quot;state&quot;, state)</span>
<span class="nc bnc" id="L429" title="All 2 branches missed."> .with(&quot;milestone&quot;, milestone == null ? &quot;none&quot; : &quot;&quot; + milestone.getNumber());</span>
<span class="nc" id="L430"> return requester.withUrlPath(getApiTailUrl(&quot;issues&quot;))</span>
<span class="nc" id="L431"> .toIterable(GHIssue[].class, item -&gt; item.wrap(this))</span>
<span class="nc" id="L432"> .toList();</span>
}
/**
* Lists up all the issues in this repository.
*
* @param state
* the state
* @return the paged iterable
*/
public PagedIterable&lt;GHIssue&gt; listIssues(final GHIssueState state) {
<span class="fc" id="L443"> return root.createRequest()</span>
<span class="fc" id="L444"> .with(&quot;state&quot;, state)</span>
<span class="fc" id="L445"> .withUrlPath(getApiTailUrl(&quot;issues&quot;))</span>
<span class="fc" id="L446"> .toIterable(GHIssue[].class, item -&gt; item.wrap(this));</span>
}
/**
* Create release gh release builder.
*
* @param tag
* the tag
* @return the gh release builder
*/
public GHReleaseBuilder createRelease(String tag) {
<span class="fc" id="L457"> return new GHReleaseBuilder(this, tag);</span>
}
/**
* Creates a named ref, such as tag, branch, etc.
*
* @param name
* The name of the fully qualified reference (ie: refs/heads/master). If it doesn't start with 'refs' and
* have at least two slashes, it will be rejected.
* @param sha
* The SHA1 value to set this reference to
* @return the gh ref
* @throws IOException
* the io exception
*/
public GHRef createRef(String name, String sha) throws IOException {
<span class="fc" id="L473"> return root.createRequest()</span>
<span class="fc" id="L474"> .method(&quot;POST&quot;)</span>
<span class="fc" id="L475"> .with(&quot;ref&quot;, name)</span>
<span class="fc" id="L476"> .with(&quot;sha&quot;, sha)</span>
<span class="fc" id="L477"> .withUrlPath(getApiTailUrl(&quot;git/refs&quot;))</span>
<span class="fc" id="L478"> .fetch(GHRef.class)</span>
<span class="fc" id="L479"> .wrap(root);</span>
}
/**
* Gets releases.
*
* @return the releases
* @throws IOException
* the io exception
* @deprecated use {@link #listReleases()}
*/
public List&lt;GHRelease&gt; getReleases() throws IOException {
<span class="fc" id="L491"> return listReleases().toList();</span>
}
/**
* Gets release.
*
* @param id
* the id
* @return the release
* @throws IOException
* the io exception
*/
public GHRelease getRelease(long id) throws IOException {
try {
<span class="fc" id="L505"> return root.createRequest().withUrlPath(getApiTailUrl(&quot;releases/&quot; + id)).fetch(GHRelease.class).wrap(this);</span>
<span class="fc" id="L506"> } catch (FileNotFoundException e) {</span>
<span class="fc" id="L507"> return null; // no release for this id</span>
}
}
/**
* Gets release by tag name.
*
* @param tag
* the tag
* @return the release by tag name
* @throws IOException
* the io exception
*/
public GHRelease getReleaseByTagName(String tag) throws IOException {
try {
<span class="fc" id="L522"> return root.createRequest()</span>
<span class="fc" id="L523"> .withUrlPath(getApiTailUrl(&quot;releases/tags/&quot; + tag))</span>
<span class="fc" id="L524"> .fetch(GHRelease.class)</span>
<span class="fc" id="L525"> .wrap(this);</span>
<span class="fc" id="L526"> } catch (FileNotFoundException e) {</span>
<span class="fc" id="L527"> return null; // no release for this tag</span>
}
}
/**
* Gets latest release.
*
* @return the latest release
* @throws IOException
* the io exception
*/
public GHRelease getLatestRelease() throws IOException {
try {
<span class="fc" id="L540"> return root.createRequest().withUrlPath(getApiTailUrl(&quot;releases/latest&quot;)).fetch(GHRelease.class).wrap(this);</span>
<span class="fc" id="L541"> } catch (FileNotFoundException e) {</span>
<span class="fc" id="L542"> return null; // no latest release</span>
}
}
/**
* List releases paged iterable.
*
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHRelease&gt; listReleases() throws IOException {
<span class="fc" id="L554"> return root.createRequest()</span>
<span class="fc" id="L555"> .withUrlPath(getApiTailUrl(&quot;releases&quot;))</span>
<span class="fc" id="L556"> .toIterable(GHRelease[].class, item -&gt; item.wrap(this));</span>
}
/**
* List tags paged iterable.
*
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHTag&gt; listTags() throws IOException {
<span class="fc" id="L567"> return root.createRequest()</span>
<span class="fc" id="L568"> .withUrlPath(getApiTailUrl(&quot;tags&quot;))</span>
<span class="fc" id="L569"> .toIterable(GHTag[].class, item -&gt; item.wrap(this));</span>
}
/**
* List languages for the specified repository. The value on the right of a language is the number of bytes of code
* written in that language. { &quot;C&quot;: 78769, &quot;Python&quot;: 7769 }
*
* @return the map
* @throws IOException
* the io exception
*/
public Map&lt;String, Long&gt; listLanguages() throws IOException {
<span class="fc" id="L581"> return root.createRequest().withUrlPath(getApiTailUrl(&quot;languages&quot;)).fetch(HashMap.class);</span>
}
/**
* Gets owner name.
*
* @return the owner name
*/
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
<span class="fc bfc" id="L594" title="All 2 branches covered."> return owner.login != null ? owner.login : owner.name;</span>
}
/**
* Has issues boolean.
*
* @return the boolean
*/
public boolean hasIssues() {
<span class="fc" id="L603"> return has_issues;</span>
}
/**
* Has projects boolean.
*
* @return the boolean
*/
public boolean hasProjects() {
<span class="fc" id="L612"> return has_projects;</span>
}
/**
* Has wiki boolean.
*
* @return the boolean
*/
public boolean hasWiki() {
<span class="fc" id="L621"> return has_wiki;</span>
}
/**
* Is fork boolean.
*
* @return the boolean
*/
public boolean isFork() {
<span class="fc" id="L630"> return fork;</span>
}
/**
* Is archived boolean.
*
* @return the boolean
*/
public boolean isArchived() {
<span class="fc" id="L639"> return archived;</span>
}
/**
* Is allow squash merge boolean.
*
* @return the boolean
*/
public boolean isAllowSquashMerge() {
<span class="fc" id="L648"> return allow_squash_merge;</span>
}
/**
* Is allow merge commit boolean.
*
* @return the boolean
*/
public boolean isAllowMergeCommit() {
<span class="fc" id="L657"> return allow_merge_commit;</span>
}
/**
* Is allow rebase merge boolean.
*
* @return the boolean
*/
public boolean isAllowRebaseMerge() {
<span class="fc" id="L666"> return allow_rebase_merge;</span>
}
/**
* Automatically deleting head branches when pull requests are merged
*
* @return the boolean
*/
public boolean isDeleteBranchOnMerge() {
<span class="fc" id="L675"> return delete_branch_on_merge;</span>
}
/**
* Returns the number of all forks of this repository. This not only counts direct forks, but also forks of forks,
* and so on.
*
* @return the forks
* @deprecated use {@link #getForksCount()} instead
*/
@Deprecated
public int getForks() {
<span class="nc" id="L687"> return getForksCount();</span>
}
/**
* Returns the number of all forks of this repository. This not only counts direct forks, but also forks of forks,
* and so on.
*
* @return the forks
*/
public int getForksCount() {
<span class="nc" id="L697"> return forks_count;</span>
}
/**
* Gets stargazers count.
*
* @return the stargazers count
*/
public int getStargazersCount() {
<span class="fc" id="L706"> return stargazers_count;</span>
}
/**
* Is private boolean.
*
* @return the boolean
*/
public boolean isPrivate() {
<span class="fc" id="L715"> return _private;</span>
}
/**
* Visibility of a repository.
*/
<span class="fc" id="L721"> public enum Visibility {</span>
<span class="fc" id="L722"> PUBLIC, INTERNAL, PRIVATE, UNKNOWN;</span>
public static Visibility from(String value) {
<span class="fc" id="L725"> return EnumUtils.getNullableEnumOrDefault(Visibility.class, value, Visibility.UNKNOWN);</span>
}
@Override
public String toString() {
<span class="fc" id="L730"> return name().toLowerCase(Locale.ROOT);</span>
}
}
/**
* Gets the visibility of the repository.
*
* @return the visibility
*/
@Deprecated
@Preview(NEBULA)
public Visibility getVisibility() {
<span class="pc bpc" id="L742" title="1 of 2 branches missed."> if (visibility == null) {</span>
try {
<span class="fc" id="L744"> populate();</span>
<span class="nc" id="L745"> } catch (final IOException e) {</span>
// Convert this to a runtime exception to avoid messy method signature
<span class="nc" id="L747"> throw new GHException(&quot;Could not populate the visibility of the repository&quot;, e);</span>
<span class="fc" id="L748"> }</span>
}
<span class="fc" id="L750"> return Visibility.from(visibility);</span>
}
/**
* Is template boolean.
*
* @return the boolean
*/
@Deprecated
@Preview(BAPTISTE)
public boolean isTemplate() {
// isTemplate is still in preview, we do not want to retrieve it unless needed.
<span class="fc bfc" id="L762" title="All 2 branches covered."> if (isTemplate == null) {</span>
try {
<span class="fc" id="L764"> populate();</span>
<span class="nc" id="L765"> } catch (IOException e) {</span>
// Convert this to a runtime exception to avoid messy method signature
<span class="nc" id="L767"> throw new GHException(&quot;Could not populate the template setting of the repository&quot;, e);</span>
<span class="fc" id="L768"> }</span>
// if this somehow is not populated, set it to false;
<span class="fc" id="L770"> isTemplate = Boolean.TRUE.equals(isTemplate);</span>
}
<span class="fc" id="L772"> return isTemplate;</span>
}
/**
* Has downloads boolean.
*
* @return the boolean
*/
public boolean hasDownloads() {
<span class="fc" id="L781"> return has_downloads;</span>
}
/**
* Has pages boolean.
*
* @return the boolean
*/
public boolean hasPages() {
<span class="fc" id="L790"> return has_pages;</span>
}
/**
* Gets watchers.
*
* @return the watchers
* @deprecated use {@link #getWatchersCount()} instead
*/
@Deprecated
public int getWatchers() {
<span class="nc" id="L801"> return getWatchersCount();</span>
}
/**
* Gets the count of watchers.
*
* @return the watchers
*/
public int getWatchersCount() {
<span class="fc" id="L810"> return watchers_count;</span>
}
/**
* Gets open issue count.
*
* @return the open issue count
*/
public int getOpenIssueCount() {
<span class="nc" id="L819"> return open_issues_count;</span>
}
/**
* Gets subscribers count.
*
* @return the subscribers count
*/
public int getSubscribersCount() {
<span class="nc" id="L828"> return subscribers_count;</span>
}
/**
* Gets pushed at.
*
* @return null if the repository was never pushed at.
*/
public Date getPushedAt() {
<span class="nc" id="L837"> return GitHubClient.parseDate(pushed_at);</span>
}
/**
* Returns the primary branch you'll configure in the &quot;Admin &amp;gt; Options&quot; config page.
*
* @return This field is null until the user explicitly configures the master branch.
*/
public String getDefaultBranch() {
<span class="nc" id="L846"> return default_branch;</span>
}
/**
* Gets master branch.
*
* @return the master branch
* @deprecated Renamed to {@link #getDefaultBranch()}
*/
@Deprecated
public String getMasterBranch() {
<span class="nc" id="L857"> return default_branch;</span>
}
/**
* Gets size.
*
* @return the size
*/
public int getSize() {
<span class="nc" id="L866"> return size;</span>
}
/**
* Affiliation of a repository collaborator
*/
<span class="fc" id="L872"> public enum CollaboratorAffiliation {</span>
<span class="fc" id="L873"> ALL, DIRECT, OUTSIDE</span>
}
/**
* Gets the collaborators on this repository. This set always appear to include the owner.
*
* @return the collaborators
* @throws IOException
* the io exception
*/
@WithBridgeMethods(Set.class)
public GHPersonSet&lt;GHUser&gt; getCollaborators() throws IOException {
<span class="fc" id="L885"> return new GHPersonSet&lt;GHUser&gt;(listCollaborators().toList());</span>
}
/**
* Lists up the collaborators on this repository.
*
* @return Users paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHUser&gt; listCollaborators() throws IOException {
<span class="fc" id="L896"> return listUsers(&quot;collaborators&quot;);</span>
}
/**
* Lists up the collaborators on this repository.
*
* @param affiliation
* Filter users by affiliation
* @return Users paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHUser&gt; listCollaborators(CollaboratorAffiliation affiliation) throws IOException {
<span class="fc" id="L909"> return listUsers(root.createRequest().with(&quot;affiliation&quot;, affiliation), &quot;collaborators&quot;);</span>
}
/**
* Lists all
* &lt;a href=&quot;https://help.github.com/articles/assigning-issues-and-pull-requests-to-other-github-users/&quot;&gt;the
* available assignees&lt;/a&gt; to which issues may be assigned.
*
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHUser&gt; listAssignees() throws IOException {
<span class="nc" id="L922"> return listUsers(&quot;assignees&quot;);</span>
}
/**
* Checks if the given user is an assignee for this repository.
*
* @param u
* the u
* @return the boolean
* @throws IOException
* the io exception
*/
public boolean hasAssignee(GHUser u) throws IOException {
<span class="nc bnc" id="L935" title="All 2 branches missed."> return root.createRequest().withUrlPath(getApiTailUrl(&quot;assignees/&quot; + u.getLogin())).fetchHttpStatusCode()</span>
/ 100 == 2;
}
/**
* Gets the names of the collaborators on this repository. This method deviates from the principle of this library
* but it works a lot faster than {@link #getCollaborators()}.
*
* @return the collaborator names
* @throws IOException
* the io exception
*/
public Set&lt;String&gt; getCollaboratorNames() throws IOException {
<span class="fc" id="L948"> Set&lt;String&gt; r = new HashSet&lt;&gt;();</span>
// no initializer - we just want to the logins
<span class="fc" id="L950"> PagedIterable&lt;GHUser&gt; users = root.createRequest()</span>
<span class="fc" id="L951"> .withUrlPath(getApiTailUrl(&quot;collaborators&quot;))</span>
<span class="fc" id="L952"> .toIterable(GHUser[].class, null);</span>
<span class="fc bfc" id="L953" title="All 2 branches covered."> for (GHUser u : users.toArray()) {</span>
<span class="fc" id="L954"> r.add(u.login);</span>
}
<span class="fc" id="L956"> return r;</span>
}
/**
* Gets the names of the collaborators on this repository. This method deviates from the principle of this library
* but it works a lot faster than {@link #getCollaborators()}.
*
* @param affiliation
* Filter users by affiliation
* @return the collaborator names
* @throws IOException
* the io exception
*/
public Set&lt;String&gt; getCollaboratorNames(CollaboratorAffiliation affiliation) throws IOException {
<span class="nc" id="L970"> Set&lt;String&gt; r = new HashSet&lt;&gt;();</span>
// no initializer - we just want to the logins
<span class="nc" id="L972"> PagedIterable&lt;GHUser&gt; users = root.createRequest()</span>
<span class="nc" id="L973"> .withUrlPath(getApiTailUrl(&quot;collaborators&quot;))</span>
<span class="nc" id="L974"> .with(&quot;affiliation&quot;, affiliation)</span>
<span class="nc" id="L975"> .toIterable(GHUser[].class, null);</span>
<span class="nc bnc" id="L976" title="All 2 branches missed."> for (GHUser u : users.toArray()) {</span>
<span class="nc" id="L977"> r.add(u.login);</span>
}
<span class="nc" id="L979"> return r;</span>
}
/**
* Obtain permission for a given user in this repository.
*
* @param user
* a {@link GHUser#getLogin}
* @return the permission
* @throws IOException
* the io exception
*/
public GHPermissionType getPermission(String user) throws IOException {
<span class="fc" id="L992"> GHPermission perm = root.createRequest()</span>
<span class="fc" id="L993"> .withUrlPath(getApiTailUrl(&quot;collaborators/&quot; + user + &quot;/permission&quot;))</span>
<span class="fc" id="L994"> .fetch(GHPermission.class);</span>
<span class="fc" id="L995"> perm.wrapUp(root);</span>
<span class="fc" id="L996"> return perm.getPermissionType();</span>
}
/**
* Obtain permission for a given user in this repository.
*
* @param u
* the user
* @return the permission
* @throws IOException
* the io exception
*/
public GHPermissionType getPermission(GHUser u) throws IOException {
<span class="nc" id="L1009"> return getPermission(u.getLogin());</span>
}
/**
* If this repository belongs to an organization, return a set of teams.
*
* @return the teams
* @throws IOException
* the io exception
*/
public Set&lt;GHTeam&gt; getTeams() throws IOException {
<span class="fc" id="L1020"> GHOrganization org = root.getOrganization(getOwnerName());</span>
<span class="fc" id="L1021"> return root.createRequest()</span>
<span class="fc" id="L1022"> .withUrlPath(getApiTailUrl(&quot;teams&quot;))</span>
<span class="fc" id="L1023"> .toIterable(GHTeam[].class, item -&gt; item.wrapUp(org))</span>
<span class="fc" id="L1024"> .toSet();</span>
}
/**
* Add collaborators.
*
* @param users
* the users
* @param permission
* the permission level
* @throws IOException
* the io exception
*/
public void addCollaborators(GHOrganization.Permission permission, GHUser... users) throws IOException {
<span class="nc" id="L1038"> addCollaborators(asList(users), permission);</span>
<span class="nc" id="L1039"> }</span>
/**
* Add collaborators.
*
* @param users
* the users
* @throws IOException
* the io exception
*/
public void addCollaborators(GHUser... users) throws IOException {
<span class="nc" id="L1050"> addCollaborators(asList(users));</span>
<span class="nc" id="L1051"> }</span>
/**
* Add collaborators.
*
* @param users
* the users
* @throws IOException
* the io exception
*/
public void addCollaborators(Collection&lt;GHUser&gt; users) throws IOException {
<span class="nc" id="L1062"> modifyCollaborators(users, &quot;PUT&quot;, null);</span>
<span class="nc" id="L1063"> }</span>
/**
* Add collaborators.
*
* @param users
* the users
* @param permission
* the permission level
* @throws IOException
* the io exception
*/
public void addCollaborators(Collection&lt;GHUser&gt; users, GHOrganization.Permission permission) throws IOException {
<span class="fc" id="L1076"> modifyCollaborators(users, &quot;PUT&quot;, permission);</span>
<span class="fc" id="L1077"> }</span>
/**
* Remove collaborators.
*
* @param users
* the users
* @throws IOException
* the io exception
*/
public void removeCollaborators(GHUser... users) throws IOException {
<span class="nc" id="L1088"> removeCollaborators(asList(users));</span>
<span class="nc" id="L1089"> }</span>
/**
* Remove collaborators.
*
* @param users
* the users
* @throws IOException
* the io exception
*/
public void removeCollaborators(Collection&lt;GHUser&gt; users) throws IOException {
<span class="nc" id="L1100"> modifyCollaborators(users, &quot;DELETE&quot;, null);</span>
<span class="nc" id="L1101"> }</span>
private void modifyCollaborators(@NonNull Collection&lt;GHUser&gt; users,
@NonNull String method,
@CheckForNull GHOrganization.Permission permission) throws IOException {
<span class="fc" id="L1106"> Requester requester = root.createRequest().method(method);</span>
<span class="pc bpc" id="L1107" title="1 of 2 branches missed."> if (permission != null) {</span>
<span class="fc" id="L1108"> requester = requester.with(&quot;permission&quot;, permission).inBody();</span>
}
// Make sure that the users collection doesn't have any duplicates
<span class="fc bfc" id="L1112" title="All 2 branches covered."> for (GHUser user : new LinkedHashSet&lt;GHUser&gt;(users)) {</span>
<span class="fc" id="L1113"> requester.withUrlPath(getApiTailUrl(&quot;collaborators/&quot; + user.getLogin())).send();</span>
<span class="fc" id="L1114"> }</span>
<span class="fc" id="L1115"> }</span>
/**
* Sets email service hook.
*
* @param address
* the address
* @throws IOException
* the io exception
*/
public void setEmailServiceHook(String address) throws IOException {
<span class="nc" id="L1126"> Map&lt;String, String&gt; config = new HashMap&lt;String, String&gt;();</span>
<span class="nc" id="L1127"> config.put(&quot;address&quot;, address);</span>
<span class="nc" id="L1128"> root.createRequest()</span>
<span class="nc" id="L1129"> .method(&quot;POST&quot;)</span>
<span class="nc" id="L1130"> .with(&quot;name&quot;, &quot;email&quot;)</span>
<span class="nc" id="L1131"> .with(&quot;config&quot;, config)</span>
<span class="nc" id="L1132"> .with(&quot;active&quot;, true)</span>
<span class="nc" id="L1133"> .withUrlPath(getApiTailUrl(&quot;hooks&quot;))</span>
<span class="nc" id="L1134"> .send();</span>
<span class="nc" id="L1135"> }</span>
/**
* Enables or disables the issue tracker for this repository.
*
* @param v
* the v
* @throws IOException
* the io exception
*/
public void enableIssueTracker(boolean v) throws IOException {
<span class="fc" id="L1146"> set().issues(v);</span>
<span class="fc" id="L1147"> }</span>
/**
* Enables or disables projects for this repository.
*
* @param v
* the v
* @throws IOException
* the io exception
*/
public void enableProjects(boolean v) throws IOException {
<span class="fc" id="L1158"> set().projects(v);</span>
<span class="fc" id="L1159"> }</span>
/**
* Enables or disables Wiki for this repository.
*
* @param v
* the v
* @throws IOException
* the io exception
*/
public void enableWiki(boolean v) throws IOException {
<span class="fc" id="L1170"> set().wiki(v);</span>
<span class="fc" id="L1171"> }</span>
/**
* Enable downloads.
*
* @param v
* the v
* @throws IOException
* the io exception
*/
public void enableDownloads(boolean v) throws IOException {
<span class="fc" id="L1182"> set().downloads(v);</span>
<span class="fc" id="L1183"> }</span>
/**
* Rename this repository.
*
* @param name
* the name
* @throws IOException
* the io exception
*/
public void renameTo(String name) throws IOException {
<span class="fc" id="L1194"> set().name(name);</span>
<span class="fc" id="L1195"> }</span>
/**
* Sets description.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
public void setDescription(String value) throws IOException {
<span class="fc" id="L1206"> set().description(value);</span>
<span class="fc" id="L1207"> }</span>
/**
* Sets homepage.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
public void setHomepage(String value) throws IOException {
<span class="nc" id="L1218"> set().homepage(value);</span>
<span class="nc" id="L1219"> }</span>
/**
* Sets default branch.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
public void setDefaultBranch(String value) throws IOException {
<span class="nc" id="L1230"> set().defaultBranch(value);</span>
<span class="nc" id="L1231"> }</span>
/**
* Sets private.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
public void setPrivate(boolean value) throws IOException {
<span class="fc" id="L1242"> set().private_(value);</span>
<span class="fc" id="L1243"> }</span>
/**
* Sets visibility.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
@Deprecated
@Preview(NEBULA)
public void setVisibility(final Visibility value) throws IOException {
<span class="fc" id="L1256"> root.createRequest()</span>
<span class="fc" id="L1257"> .method(&quot;PATCH&quot;)</span>
<span class="fc" id="L1258"> .withPreview(NEBULA)</span>
<span class="fc" id="L1259"> .with(&quot;name&quot;, name)</span>
<span class="fc" id="L1260"> .with(&quot;visibility&quot;, value)</span>
<span class="fc" id="L1261"> .withUrlPath(getApiTailUrl(&quot;&quot;))</span>
<span class="fc" id="L1262"> .send();</span>
<span class="fc" id="L1263"> }</span>
/**
* Allow squash merge.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
public void allowSquashMerge(boolean value) throws IOException {
<span class="fc" id="L1274"> set().allowSquashMerge(value);</span>
<span class="fc" id="L1275"> }</span>
/**
* Allow merge commit.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
public void allowMergeCommit(boolean value) throws IOException {
<span class="fc" id="L1286"> set().allowMergeCommit(value);</span>
<span class="fc" id="L1287"> }</span>
/**
* Allow rebase merge.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
public void allowRebaseMerge(boolean value) throws IOException {
<span class="fc" id="L1298"> set().allowRebaseMerge(value);</span>
<span class="fc" id="L1299"> }</span>
/**
* After pull requests are merged, you can have head branches deleted automatically.
*
* @param value
* the value
* @throws IOException
* the io exception
*/
public void deleteBranchOnMerge(boolean value) throws IOException {
<span class="fc" id="L1310"> set().deleteBranchOnMerge(value);</span>
<span class="fc" id="L1311"> }</span>
/**
* Deletes this repository.
*
* @throws IOException
* the io exception
*/
public void delete() throws IOException {
try {
<span class="fc" id="L1321"> root.createRequest().method(&quot;DELETE&quot;).withUrlPath(getApiTailUrl(&quot;&quot;)).send();</span>
<span class="nc" id="L1322"> } catch (FileNotFoundException x) {</span>
<span class="nc" id="L1323"> throw (FileNotFoundException) new FileNotFoundException(&quot;Failed to delete &quot; + getOwnerName() + &quot;/&quot; + name</span>
+ &quot;; might not exist, or you might need the delete_repo scope in your token: http://stackoverflow.com/a/19327004/12916&quot;)
<span class="nc" id="L1325"> .initCause(x);</span>
<span class="fc" id="L1326"> }</span>
<span class="fc" id="L1327"> }</span>
/**
* Will archive and this repository as read-only. When a repository is archived, any operation that can change its
* state is forbidden. This applies symmetrically if trying to unarchive it.
*
* &lt;p&gt;
* When you try to do any operation that modifies a read-only repository, it returns the response:
*
* &lt;pre&gt;
* org.kohsuke.github.HttpException: {
* &quot;message&quot;:&quot;Repository was archived so is read-only.&quot;,
* &quot;documentation_url&quot;:&quot;https://developer.github.com/v3/repos/#edit&quot;
* }
* &lt;/pre&gt;
*
* @throws IOException
* In case of any networking error or error from the server.
*/
public void archive() throws IOException {
<span class="fc" id="L1347"> set().archive();</span>
// Generally would not update this record,
// but doing so here since this will result in any other update actions failing
<span class="fc" id="L1350"> archived = true;</span>
<span class="fc" id="L1351"> }</span>
/**
* Creates a builder that can be used to bulk update repository settings.
*
* @return the repository updater
*/
public Updater update() {
<span class="fc" id="L1359"> return new Updater(this);</span>
}
/**
* Creates a builder that can be used to bulk update repository settings.
*
* @return the repository updater
*/
public Setter set() {
<span class="fc" id="L1368"> return new Setter(this);</span>
}
/**
* Sort orders for listing forks
*/
<span class="fc" id="L1374"> public enum ForkSort {</span>
<span class="fc" id="L1375"> NEWEST, OLDEST, STARGAZERS</span>
}
/**
* Lists all the direct forks of this repository, sorted by github api default, currently {@link ForkSort#NEWEST
* ForkSort.NEWEST}*.
*
* @return the paged iterable
*/
public PagedIterable&lt;GHRepository&gt; listForks() {
<span class="nc" id="L1385"> return listForks(null);</span>
}
/**
* Lists all the direct forks of this repository, sorted by the given sort order.
*
* @param sort
* the sort order. If null, defaults to github api default, currently {@link ForkSort#NEWEST
* ForkSort.NEWEST}.
* @return the paged iterable
*/
public PagedIterable&lt;GHRepository&gt; listForks(final ForkSort sort) {
<span class="nc" id="L1397"> return root.createRequest()</span>
<span class="nc" id="L1398"> .with(&quot;sort&quot;, sort)</span>
<span class="nc" id="L1399"> .withUrlPath(getApiTailUrl(&quot;forks&quot;))</span>
<span class="nc" id="L1400"> .toIterable(GHRepository[].class, item -&gt; item.wrap(root));</span>
}
/**
* Forks this repository as your repository.
*
* @return Newly forked repository that belong to you.
* @throws IOException
* the io exception
*/
public GHRepository fork() throws IOException {
<span class="nc" id="L1411"> root.createRequest().method(&quot;POST&quot;).withUrlPath(getApiTailUrl(&quot;forks&quot;)).send();</span>
// this API is asynchronous. we need to wait for a bit
<span class="nc bnc" id="L1414" title="All 2 branches missed."> for (int i = 0; i &lt; 10; i++) {</span>
<span class="nc" id="L1415"> GHRepository r = root.getMyself().getRepository(name);</span>
<span class="nc bnc" id="L1416" title="All 2 branches missed."> if (r != null) {</span>
<span class="nc" id="L1417"> return r;</span>
}
try {
<span class="nc" id="L1420"> Thread.sleep(3000);</span>
<span class="nc" id="L1421"> } catch (InterruptedException e) {</span>
<span class="nc" id="L1422"> throw (IOException) new InterruptedIOException().initCause(e);</span>
<span class="nc" id="L1423"> }</span>
}
<span class="nc" id="L1425"> throw new IOException(this + &quot; was forked but can't find the new repository&quot;);</span>
}
/**
* Forks this repository into an organization.
*
* @param org
* the org
* @return Newly forked repository that belong to you.
* @throws IOException
* the io exception
*/
public GHRepository forkTo(GHOrganization org) throws IOException {
<span class="fc" id="L1438"> root.createRequest()</span>
<span class="fc" id="L1439"> .method(&quot;POST&quot;)</span>
<span class="fc" id="L1440"> .with(&quot;organization&quot;, org.getLogin())</span>
<span class="fc" id="L1441"> .withUrlPath(getApiTailUrl(&quot;forks&quot;))</span>
<span class="fc" id="L1442"> .send();</span>
// this API is asynchronous. we need to wait for a bit
<span class="pc bpc" id="L1445" title="1 of 2 branches missed."> for (int i = 0; i &lt; 10; i++) {</span>
<span class="fc" id="L1446"> GHRepository r = org.getRepository(name);</span>
<span class="pc bpc" id="L1447" title="1 of 2 branches missed."> if (r != null) {</span>
<span class="fc" id="L1448"> return r;</span>
}
try {
<span class="nc" id="L1451"> Thread.sleep(3000);</span>
<span class="nc" id="L1452"> } catch (InterruptedException e) {</span>
<span class="nc" id="L1453"> throw (IOException) new InterruptedIOException().initCause(e);</span>
<span class="nc" id="L1454"> }</span>
}
<span class="nc" id="L1456"> throw new IOException(this + &quot; was forked into &quot; + org.getLogin() + &quot; but can't find the new repository&quot;);</span>
}
/**
* Retrieves a specified pull request.
*
* @param i
* the
* @return the pull request
* @throws IOException
* the io exception
*/
public GHPullRequest getPullRequest(int i) throws IOException {
<span class="fc" id="L1469"> return root.createRequest()</span>
<span class="fc" id="L1470"> .withPreview(SHADOW_CAT)</span>
<span class="fc" id="L1471"> .withUrlPath(getApiTailUrl(&quot;pulls/&quot; + i))</span>
<span class="fc" id="L1472"> .fetch(GHPullRequest.class)</span>
<span class="fc" id="L1473"> .wrapUp(this);</span>
}
/**
* Retrieves all the pull requests of a particular state.
*
* @param state
* the state
* @return the pull requests
* @throws IOException
* the io exception
* @see #listPullRequests(GHIssueState) #listPullRequests(GHIssueState)
*/
public List&lt;GHPullRequest&gt; getPullRequests(GHIssueState state) throws IOException {
<span class="nc" id="L1487"> return queryPullRequests().state(state).list().toList();</span>
}
/**
* Retrieves all the pull requests of a particular state.
*
* @param state
* the state
* @return the paged iterable
* @deprecated Use {@link #queryPullRequests()}
*/
@Deprecated
public PagedIterable&lt;GHPullRequest&gt; listPullRequests(GHIssueState state) {
<span class="fc" id="L1500"> return queryPullRequests().state(state).list();</span>
}
/**
* Retrieves pull requests.
*
* @return the gh pull request query builder
*/
public GHPullRequestQueryBuilder queryPullRequests() {
<span class="fc" id="L1509"> return new GHPullRequestQueryBuilder(this);</span>
}
/**
* Creates a new pull request.
*
* @param title
* Required. The title of the pull request.
* @param head
* Required. The name of the branch where your changes are implemented. For cross-repository pull
* requests in the same network, namespace head with a user like this: username:branch.
* @param base
* Required. The name of the branch you want your changes pulled into. This should be an existing branch
* on the current repository.
* @param body
* The contents of the pull request. This is the markdown description of a pull request.
* @return the gh pull request
* @throws IOException
* the io exception
*/
public GHPullRequest createPullRequest(String title, String head, String base, String body) throws IOException {
<span class="fc" id="L1530"> return createPullRequest(title, head, base, body, true);</span>
}
/**
* Creates a new pull request. Maintainer's permissions aware.
*
* @param title
* Required. The title of the pull request.
* @param head
* Required. The name of the branch where your changes are implemented. For cross-repository pull
* requests in the same network, namespace head with a user like this: username:branch.
* @param base
* Required. The name of the branch you want your changes pulled into. This should be an existing branch
* on the current repository.
* @param body
* The contents of the pull request. This is the markdown description of a pull request.
* @param maintainerCanModify
* Indicates whether maintainers can modify the pull request.
* @return the gh pull request
* @throws IOException
* the io exception
*/
public GHPullRequest createPullRequest(String title,
String head,
String base,
String body,
boolean maintainerCanModify) throws IOException {
<span class="fc" id="L1557"> return createPullRequest(title, head, base, body, maintainerCanModify, false);</span>
}
/**
* Creates a new pull request. Maintainer's permissions and draft aware.
*
* @param title
* Required. The title of the pull request.
* @param head
* Required. The name of the branch where your changes are implemented. For cross-repository pull
* requests in the same network, namespace head with a user like this: username:branch.
* @param base
* Required. The name of the branch you want your changes pulled into. This should be an existing branch
* on the current repository.
* @param body
* The contents of the pull request. This is the markdown description of a pull request.
* @param maintainerCanModify
* Indicates whether maintainers can modify the pull request.
* @param draft
* Indicates whether to create a draft pull request or not.
* @return the gh pull request
* @throws IOException
* the io exception
*/
public GHPullRequest createPullRequest(String title,
String head,
String base,
String body,
boolean maintainerCanModify,
boolean draft) throws IOException {
<span class="fc" id="L1587"> return root.createRequest()</span>
<span class="fc" id="L1588"> .method(&quot;POST&quot;)</span>
<span class="fc" id="L1589"> .withPreview(SHADOW_CAT)</span>
<span class="fc" id="L1590"> .with(&quot;title&quot;, title)</span>
<span class="fc" id="L1591"> .with(&quot;head&quot;, head)</span>
<span class="fc" id="L1592"> .with(&quot;base&quot;, base)</span>
<span class="fc" id="L1593"> .with(&quot;body&quot;, body)</span>
<span class="fc" id="L1594"> .with(&quot;maintainer_can_modify&quot;, maintainerCanModify)</span>
<span class="fc" id="L1595"> .with(&quot;draft&quot;, draft)</span>
<span class="fc" id="L1596"> .withUrlPath(getApiTailUrl(&quot;pulls&quot;))</span>
<span class="fc" id="L1597"> .fetch(GHPullRequest.class)</span>
<span class="fc" id="L1598"> .wrapUp(this);</span>
}
/**
* Retrieves the currently configured hooks.
*
* @return the hooks
* @throws IOException
* the io exception
*/
public List&lt;GHHook&gt; getHooks() throws IOException {
<span class="fc" id="L1609"> return GHHooks.repoContext(this, owner).getHooks();</span>
}
/**
* Gets hook.
*
* @param id
* the id
* @return the hook
* @throws IOException
* the io exception
*/
public GHHook getHook(int id) throws IOException {
<span class="fc" id="L1622"> return GHHooks.repoContext(this, owner).getHook(id);</span>
}
/**
* Gets a comparison between 2 points in the repository. This would be similar to calling
* &lt;code&gt;git log id1...id2&lt;/code&gt; 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 {
<span class="nc" id="L1639"> GHCompare compare = root.createRequest()</span>
<span class="nc" id="L1640"> .withUrlPath(getApiTailUrl(String.format(&quot;compare/%s...%s&quot;, id1, id2)))</span>
<span class="nc" id="L1641"> .fetch(GHCompare.class);</span>
<span class="nc" id="L1642"> return compare.wrap(this);</span>
}
/**
* Gets compare.
*
* @param id1
* the id 1
* @param id2
* the id 2
* @return the compare
* @throws IOException
* the io exception
*/
public GHCompare getCompare(GHCommit id1, GHCommit id2) throws IOException {
<span class="nc" id="L1657"> return getCompare(id1.getSHA1(), id2.getSHA1());</span>
}
/**
* Gets compare.
*
* @param id1
* the id 1
* @param id2
* the id 2
* @return the compare
* @throws IOException
* the io exception
*/
public GHCompare getCompare(GHBranch id1, GHBranch id2) throws IOException {
<span class="nc" id="L1673"> GHRepository owner1 = id1.getOwner();</span>
<span class="nc" id="L1674"> GHRepository owner2 = id2.getOwner();</span>
// If the owner of the branches is different, we have a cross-fork compare.
<span class="nc bnc" id="L1677" title="All 4 branches missed."> if (owner1 != null &amp;&amp; owner2 != null) {</span>
<span class="nc" id="L1678"> String ownerName1 = owner1.getOwnerName();</span>
<span class="nc" id="L1679"> String ownerName2 = owner2.getOwnerName();</span>
<span class="nc bnc" id="L1680" title="All 2 branches missed."> if (!StringUtils.equals(ownerName1, ownerName2)) {</span>
<span class="nc" id="L1681"> String qualifiedName1 = String.format(&quot;%s:%s&quot;, ownerName1, id1.getName());</span>
<span class="nc" id="L1682"> String qualifiedName2 = String.format(&quot;%s:%s&quot;, ownerName2, id2.getName());</span>
<span class="nc" id="L1683"> return getCompare(qualifiedName1, qualifiedName2);</span>
}
}
<span class="nc" id="L1687"> return getCompare(id1.getName(), id2.getName());</span>
}
/**
* 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 {
<span class="fc" id="L1699"> return listRefs().toArray();</span>
}
/**
* Retrieves all refs for the github repository.
*
* @return paged iterable of all refs
* @throws IOException
* on failure communicating with GitHub, potentially due to an invalid ref type being requested
*/
public PagedIterable&lt;GHRef&gt; listRefs() throws IOException {
<span class="fc" id="L1710"> return listRefs(&quot;&quot;);</span>
}
/**
* Retrieves all refs of the given type for the current GitHub repository.
*
* @param refType
* the type of reg to search for e.g. &lt;code&gt;tags&lt;/code&gt; or &lt;code&gt;commits&lt;/code&gt;
* @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 {
<span class="fc" id="L1723"> return listRefs(refType).toArray();</span>
}
/**
* Retrieves all refs of the given type for the current GitHub repository.
*
* @param refType
* the type of reg to search for e.g. &lt;code&gt;tags&lt;/code&gt; or &lt;code&gt;commits&lt;/code&gt;
* @return paged iterable of all refs of the specified type
* @throws IOException
* on failure communicating with GitHub, potentially due to an invalid ref type being requested
*/
public PagedIterable&lt;GHRef&gt; listRefs(String refType) throws IOException {
<span class="fc" id="L1736"> return GHRef.readMatching(this, refType);</span>
}
/**
* Retrive a ref of the given type for the current GitHub repository.
*
* @param refName
* eg: heads/branch
* @return refs matching the request type
* @throws IOException
* on failure communicating with GitHub, potentially due to an invalid ref type being requested
*/
public GHRef getRef(String refName) throws IOException {
<span class="fc" id="L1749"> return GHRef.read(this, refName);</span>
}
/**
* Returns the &lt;strong&gt;annotated&lt;/strong&gt; tag object. Only valid if the {@link GHRef#getObject()} has a
* {@link GHRef.GHObject#getType()} of {@code tag}.
*
* @param sha
* the sha of the tag object
* @return the annotated tag object
* @throws IOException
* the io exception
*/
public GHTagObject getTagObject(String sha) throws IOException {
<span class="nc" id="L1763"> return root.createRequest().withUrlPath(getApiTailUrl(&quot;git/tags/&quot; + sha)).fetch(GHTagObject.class).wrap(this);</span>
}
/**
* Retrive a tree of the given type for the current GitHub repository.
*
* @param sha
* sha number or branch name ex: &quot;master&quot;
* @return refs matching the request type
* @throws IOException
* on failure communicating with GitHub, potentially due to an invalid tree type being requested
*/
public GHTree getTree(String sha) throws IOException {
<span class="fc" id="L1776"> String url = String.format(&quot;/repos/%s/%s/git/trees/%s&quot;, getOwnerName(), name, sha);</span>
<span class="fc" id="L1777"> return root.createRequest().withUrlPath(url).fetch(GHTree.class).wrap(this);</span>
}
/**
* Create tree gh tree builder.
*
* @return the gh tree builder
*/
public GHTreeBuilder createTree() {
<span class="fc" id="L1786"> return new GHTreeBuilder(this);</span>
}
/**
* Retrieves the tree for the current GitHub repository, recursively as described in here:
* https://developer.github.com/v3/git/trees/#get-a-tree-recursively
*
* @param sha
* sha number or branch name ex: &quot;master&quot;
* @param recursive
* use 1
* @return the tree recursive
* @throws IOException
* on failure communicating with GitHub, potentially due to an invalid tree type being requested
*/
public GHTree getTreeRecursive(String sha, int recursive) throws IOException {
<span class="fc" id="L1802"> String url = String.format(&quot;/repos/%s/%s/git/trees/%s&quot;, getOwnerName(), name, sha);</span>
<span class="fc" id="L1803"> return root.createRequest().with(&quot;recursive&quot;, recursive).withUrlPath(url).fetch(GHTree.class).wrap(this);</span>
}
/**
* Obtains the metadata &amp;amp; the content of a blob.
*
* &lt;p&gt;
* This method retrieves the whole content in memory, so beware when you are dealing with large BLOB.
*
* @param blobSha
* the blob sha
* @return the blob
* @throws IOException
* the io exception
* @see &lt;a href=&quot;https://developer.github.com/v3/git/blobs/#get-a-blob&quot;&gt;Get a blob&lt;/a&gt;
* @see #readBlob(String) #readBlob(String)
*/
public GHBlob getBlob(String blobSha) throws IOException {
<span class="fc" id="L1821"> String target = getApiTailUrl(&quot;git/blobs/&quot; + blobSha);</span>
<span class="fc" id="L1822"> return root.createRequest().withUrlPath(target).fetch(GHBlob.class);</span>
}
/**
* Create blob gh blob builder.
*
* @return the gh blob builder
*/
public GHBlobBuilder createBlob() {
<span class="fc" id="L1831"> return new GHBlobBuilder(this);</span>
}
/**
* Reads the content of a blob as a stream for better efficiency.
*
* @param blobSha
* the blob sha
* @return the input stream
* @throws IOException
* the io exception
* @see &lt;a href=&quot;https://developer.github.com/v3/git/blobs/#get-a-blob&quot;&gt;Get a blob&lt;/a&gt;
* @see #getBlob(String) #getBlob(String)
*/
public InputStream readBlob(String blobSha) throws IOException {
<span class="fc" id="L1846"> String target = getApiTailUrl(&quot;git/blobs/&quot; + blobSha);</span>
// https://developer.github.com/v3/media/ describes this media type
<span class="fc" id="L1849"> return root.createRequest()</span>
<span class="fc" id="L1850"> .withHeader(&quot;Accept&quot;, &quot;application/vnd.github.v3.raw&quot;)</span>
<span class="fc" id="L1851"> .withUrlPath(target)</span>
<span class="fc" id="L1852"> .fetchStream(Requester::copyInputStream);</span>
}
/**
* Gets a commit object in this repository.
*
* @param sha1
* the sha 1
* @return the commit
* @throws IOException
* the io exception
*/
public GHCommit getCommit(String sha1) throws IOException {
<span class="fc" id="L1865"> GHCommit c = commits.get(sha1);</span>
<span class="pc bpc" id="L1866" title="1 of 2 branches missed."> if (c == null) {</span>
<span class="fc" id="L1867"> c = root.createRequest()</span>
<span class="fc" id="L1868"> .withUrlPath(String.format(&quot;/repos/%s/%s/commits/%s&quot;, getOwnerName(), name, sha1))</span>
<span class="fc" id="L1869"> .fetch(GHCommit.class)</span>
<span class="fc" id="L1870"> .wrapUp(this);</span>
<span class="fc" id="L1871"> commits.put(sha1, c);</span>
}
<span class="fc" id="L1873"> return c;</span>
}
/**
* Create commit gh commit builder.
*
* @return the gh commit builder
*/
public GHCommitBuilder createCommit() {
<span class="fc" id="L1882"> return new GHCommitBuilder(this);</span>
}
/**
* Lists all the commits.
*
* @return the paged iterable
*/
public PagedIterable&lt;GHCommit&gt; listCommits() {
<span class="fc" id="L1891"> return root.createRequest()</span>
<span class="fc" id="L1892"> .withUrlPath(String.format(&quot;/repos/%s/%s/commits&quot;, getOwnerName(), name))</span>
<span class="fc" id="L1893"> .toIterable(GHCommit[].class, item -&gt; item.wrapUp(this));</span>
}
/**
* Search commits by specifying filters through a builder pattern.
*
* @return the gh commit query builder
*/
public GHCommitQueryBuilder queryCommits() {
<span class="fc" id="L1902"> return new GHCommitQueryBuilder(this);</span>
}
/**
* Lists up all the commit comments in this repository.
*
* @return the paged iterable
*/
public PagedIterable&lt;GHCommitComment&gt; listCommitComments() {
<span class="fc" id="L1911"> return root.createRequest()</span>
<span class="fc" id="L1912"> .withUrlPath(String.format(&quot;/repos/%s/%s/comments&quot;, getOwnerName(), name))</span>
<span class="fc" id="L1913"> .toIterable(GHCommitComment[].class, item -&gt; item.wrap(this));</span>
}
/**
* Lists all comments on a specific commit.
*
* @param commitSha
* the hash of the commit
*
* @return the paged iterable
*/
public PagedIterable&lt;GHCommitComment&gt; listCommitComments(String commitSha) {
<span class="fc" id="L1925"> return root.createRequest()</span>
<span class="fc" id="L1926"> .withUrlPath(String.format(&quot;/repos/%s/%s/commits/%s/comments&quot;, getOwnerName(), name, commitSha))</span>
<span class="fc" id="L1927"> .toIterable(GHCommitComment[].class, item -&gt; item.wrap(this));</span>
}
/**
* Gets the basic license details for the repository.
* &lt;p&gt;
*
* @return null if there's no license.
* @throws IOException
* as usual but also if you don't use the preview connector
*/
public GHLicense getLicense() throws IOException {
<span class="fc" id="L1939"> GHContentWithLicense lic = getLicenseContent_();</span>
<span class="fc bfc" id="L1940" title="All 2 branches covered."> return lic != null ? lic.license : null;</span>
}
/**
* Retrieves the contents of the repository's license file - makes an additional API call
* &lt;p&gt;
*
* @return details regarding the license contents, or null if there's no license.
* @throws IOException
* as usual but also if you don't use the preview connector
*/
public GHContent getLicenseContent() throws IOException {
<span class="fc" id="L1952"> return getLicenseContent_();</span>
}
private GHContentWithLicense getLicenseContent_() throws IOException {
try {
<span class="fc" id="L1957"> return root.createRequest()</span>
<span class="fc" id="L1958"> .withUrlPath(getApiTailUrl(&quot;license&quot;))</span>
<span class="fc" id="L1959"> .fetch(GHContentWithLicense.class)</span>
<span class="fc" id="L1960"> .wrap(this);</span>
<span class="fc" id="L1961"> } catch (FileNotFoundException e) {</span>
<span class="fc" id="L1962"> return null;</span>
}
}
/**
* /** Lists all the commit statuses attached to the given commit, newer ones first.
*
* @param sha1
* the sha 1
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHCommitStatus&gt; listCommitStatuses(final String sha1) throws IOException {
<span class="fc" id="L1976"> return root.createRequest()</span>
<span class="fc" id="L1977"> .withUrlPath(String.format(&quot;/repos/%s/%s/statuses/%s&quot;, getOwnerName(), name, sha1))</span>
<span class="fc" id="L1978"> .toIterable(GHCommitStatus[].class, item -&gt; item.wrapUp(root));</span>
}
/**
* Gets the last status of this commit, which is what gets shown in the UI.
*
* @param sha1
* the sha 1
* @return the last commit status
* @throws IOException
* the io exception
*/
public GHCommitStatus getLastCommitStatus(String sha1) throws IOException {
<span class="fc" id="L1991"> List&lt;GHCommitStatus&gt; v = listCommitStatuses(sha1).toList();</span>
<span class="pc bpc" id="L1992" title="1 of 2 branches missed."> return v.isEmpty() ? null : v.get(0);</span>
}
/**
* Gets check runs for given ref.
*
* @param ref
* ref
* @return check runs for given ref
* @throws IOException
* the io exception
* @see &lt;a href=&quot;https://developer.github.com/v3/checks/runs/#list-check-runs-for-a-specific-ref&quot;&gt;List check runs
* for a specific ref&lt;/a&gt;
*/
@Preview(ANTIOPE)
@Deprecated
public PagedIterable&lt;GHCheckRun&gt; getCheckRuns(String ref) throws IOException {
<span class="fc" id="L2009"> GitHubRequest request = root.createRequest()</span>
<span class="fc" id="L2010"> .withUrlPath(String.format(&quot;/repos/%s/%s/commits/%s/check-runs&quot;, getOwnerName(), name, ref))</span>
<span class="fc" id="L2011"> .withPreview(ANTIOPE)</span>
<span class="fc" id="L2012"> .build();</span>
<span class="fc" id="L2013"> return new GHCheckRunsIterable(root, request);</span>
}
/**
* Creates a commit status
*
* @param sha1
* the sha 1
* @param state
* the state
* @param targetUrl
* Optional parameter that points to the URL that has more details.
* @param description
* Optional short description.
* @param context
* Optinal commit status context.
* @return the gh commit status
* @throws IOException
* the io exception
*/
public GHCommitStatus createCommitStatus(String sha1,
GHCommitState state,
String targetUrl,
String description,
String context) throws IOException {
<span class="nc" id="L2038"> return root.createRequest()</span>
<span class="nc" id="L2039"> .method(&quot;POST&quot;)</span>
<span class="nc" id="L2040"> .with(&quot;state&quot;, state)</span>
<span class="nc" id="L2041"> .with(&quot;target_url&quot;, targetUrl)</span>
<span class="nc" id="L2042"> .with(&quot;description&quot;, description)</span>
<span class="nc" id="L2043"> .with(&quot;context&quot;, context)</span>
<span class="nc" id="L2044"> .withUrlPath(String.format(&quot;/repos/%s/%s/statuses/%s&quot;, getOwnerName(), this.name, sha1))</span>
<span class="nc" id="L2045"> .fetch(GHCommitStatus.class)</span>
<span class="nc" id="L2046"> .wrapUp(root);</span>
}
/**
* Create commit status gh commit status.
*
* @param sha1
* the sha 1
* @param state
* the state
* @param targetUrl
* the target url
* @param description
* the description
* @return the gh commit status
* @throws IOException
* the io exception
* @see #createCommitStatus(String, GHCommitState, String, String, String) #createCommitStatus(String,
* GHCommitState,String,String,String)
*/
public GHCommitStatus createCommitStatus(String sha1, GHCommitState state, String targetUrl, String description)
throws IOException {
<span class="nc" id="L2068"> return createCommitStatus(sha1, state, targetUrl, description, null);</span>
}
/**
* Creates a check run for a commit.
*
* @param name
* an identifier for the run
* @param headSHA
* the commit hash
* @return a builder which you should customize, then call {@link GHCheckRunBuilder#create}
*/
@Preview(ANTIOPE)
@Deprecated
public @NonNull GHCheckRunBuilder createCheckRun(@NonNull String name, @NonNull String headSHA) {
<span class="fc" id="L2083"> return new GHCheckRunBuilder(this, name, headSHA);</span>
}
/**
* Updates an existing check run.
*
* @param checkId
* the existing checkId
* @return a builder which you should customize, then call {@link GHCheckRunBuilder#create}
*/
@Preview(BAPTISTE)
@Deprecated
public @NonNull GHCheckRunBuilder updateCheckRun(long checkId) {
<span class="nc" id="L2096"> return new GHCheckRunBuilder(this, checkId);</span>
}
/**
* Lists repository events.
*
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHEventInfo&gt; listEvents() throws IOException {
<span class="nc" id="L2107"> return root.createRequest()</span>
<span class="nc" id="L2108"> .withUrlPath(String.format(&quot;/repos/%s/%s/events&quot;, getOwnerName(), name))</span>
<span class="nc" id="L2109"> .toIterable(GHEventInfo[].class, item -&gt; item.wrapUp(root));</span>
}
/**
* Lists labels in this repository.
* &lt;p&gt;
* https://developer.github.com/v3/issues/labels/#list-all-labels-for-this-repository
*
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHLabel&gt; listLabels() throws IOException {
<span class="fc" id="L2122"> return GHLabel.readAll(this);</span>
}
/**
* Gets label.
*
* @param name
* the name
* @return the label
* @throws IOException
* the io exception
*/
public GHLabel getLabel(String name) throws IOException {
<span class="fc" id="L2135"> return GHLabel.read(this, name);</span>
}
/**
* Create label gh label.
*
* @param name
* the name
* @param color
* the color
* @return the gh label
* @throws IOException
* the io exception
*/
public GHLabel createLabel(String name, String color) throws IOException {
<span class="fc" id="L2150"> return GHLabel.create(this).name(name).color(color).description(&quot;&quot;).done();</span>
}
/**
* Description is still in preview.
*
* @param name
* the name
* @param color
* the color
* @param description
* the description
* @return gh label
* @throws IOException
* the io exception
*/
public GHLabel createLabel(String name, String color, String description) throws IOException {
<span class="fc" id="L2167"> return GHLabel.create(this).name(name).color(color).description(description).done();</span>
}
/**
* Lists all the invitations.
*
* @return the paged iterable
*/
public PagedIterable&lt;GHInvitation&gt; listInvitations() {
<span class="nc" id="L2176"> return root.createRequest()</span>
<span class="nc" id="L2177"> .withUrlPath(String.format(&quot;/repos/%s/%s/invitations&quot;, getOwnerName(), name))</span>
<span class="nc" id="L2178"> .toIterable(GHInvitation[].class, item -&gt; item.wrapUp(root));</span>
}
/**
* Lists all the subscribers (aka watchers.)
* &lt;p&gt;
* https://developer.github.com/v3/activity/watching/
*
* @return the paged iterable
*/
public PagedIterable&lt;GHUser&gt; listSubscribers() {
<span class="fc" id="L2189"> return listUsers(&quot;subscribers&quot;);</span>
}
/**
* Lists all the users who have starred this repo based on the old version of the API. For additional information,
* like date when the repository was starred, see {@link #listStargazers2()}
*
* @return the paged iterable
*/
public PagedIterable&lt;GHUser&gt; listStargazers() {
<span class="nc" id="L2199"> return listUsers(&quot;stargazers&quot;);</span>
}
/**
* Lists all the users who have starred this repo based on new version of the API, having extended information like
* the time when the repository was starred. For compatibility with the old API see {@link #listStargazers()}
*
* @return the paged iterable
*/
public PagedIterable&lt;GHStargazer&gt; listStargazers2() {
<span class="fc" id="L2209"> return root.createRequest()</span>
<span class="fc" id="L2210"> .withPreview(&quot;application/vnd.github.v3.star+json&quot;)</span>
<span class="fc" id="L2211"> .withUrlPath(getApiTailUrl(&quot;stargazers&quot;))</span>
<span class="fc" id="L2212"> .toIterable(GHStargazer[].class, item -&gt; item.wrapUp(this));</span>
}
private PagedIterable&lt;GHUser&gt; listUsers(final String suffix) {
<span class="fc" id="L2216"> return listUsers(root.createRequest(), suffix);</span>
}
private PagedIterable&lt;GHUser&gt; listUsers(Requester requester, final String suffix) {
<span class="fc" id="L2220"> return requester.withUrlPath(getApiTailUrl(suffix)).toIterable(GHUser[].class, item -&gt; item.wrapUp(root));</span>
}
/**
* See https://api.github.com/hooks for possible names and their configuration scheme. TODO: produce type-safe
* binding
*
* @param name
* Type of the hook to be created. See https://api.github.com/hooks for possible names.
* @param config
* The configuration hash.
* @param events
* Can be null. Types of events to hook into.
* @param active
* the active
* @return the gh hook
* @throws IOException
* the io exception
*/
public GHHook createHook(String name, Map&lt;String, String&gt; config, Collection&lt;GHEvent&gt; events, boolean active)
throws IOException {
<span class="fc" id="L2241"> return GHHooks.repoContext(this, owner).createHook(name, config, events, active);</span>
}
/**
* Create web hook gh hook.
*
* @param url
* the url
* @param events
* the events
* @return the gh hook
* @throws IOException
* the io exception
*/
public GHHook createWebHook(URL url, Collection&lt;GHEvent&gt; events) throws IOException {
<span class="fc" id="L2256"> return createHook(&quot;web&quot;, Collections.singletonMap(&quot;url&quot;, url.toExternalForm()), events, true);</span>
}
/**
* Create web hook gh hook.
*
* @param url
* the url
* @return the gh hook
* @throws IOException
* the io exception
*/
public GHHook createWebHook(URL url) throws IOException {
<span class="fc" id="L2269"> return createWebHook(url, null);</span>
}
/**
* Returns a set that represents the post-commit hook URLs. The returned set is live, and changes made to them are
* reflected to GitHub.
*
* @return the post commit hooks
* @deprecated Use {@link #getHooks()} and {@link #createHook(String, Map, Collection, boolean)}
*/
@SuppressFBWarnings(value = &quot;DMI_COLLECTION_OF_URLS&quot;,
justification = &quot;It causes a performance degradation, but we have already exposed it to the API&quot;)
@Deprecated
public Set&lt;URL&gt; getPostCommitHooks() {
<span class="fc" id="L2283"> synchronized (this) {</span>
<span class="pc bpc" id="L2284" title="1 of 2 branches missed."> if (postCommitHooks == null) {</span>
<span class="fc" id="L2285"> postCommitHooks = setupPostCommitHooks();</span>
}
<span class="fc" id="L2287"> return postCommitHooks;</span>
}
}
/**
* Live set view of the post-commit hook.
*/
@SuppressFBWarnings(value = &quot;DMI_COLLECTION_OF_URLS&quot;,
justification = &quot;It causes a performance degradation, but we have already exposed it to the API&quot;)
@SkipFromToString
private /* final */ transient Set&lt;URL&gt; postCommitHooks;
@SuppressFBWarnings(value = &quot;DMI_COLLECTION_OF_URLS&quot;,
justification = &quot;It causes a performance degradation, but we have already exposed it to the API&quot;)
private Set&lt;URL&gt; setupPostCommitHooks() {
<span class="fc" id="L2302"> return new AbstractSet&lt;URL&gt;() {</span>
private List&lt;URL&gt; getPostCommitHooks() {
try {
<span class="fc" id="L2305"> List&lt;URL&gt; r = new ArrayList&lt;&gt;();</span>
<span class="pc bpc" id="L2306" title="1 of 2 branches missed."> for (GHHook h : getHooks()) {</span>
<span class="nc bnc" id="L2307" title="All 2 branches missed."> if (h.getName().equals(&quot;web&quot;)) {</span>
<span class="nc" id="L2308"> r.add(new URL(h.getConfig().get(&quot;url&quot;)));</span>
}
<span class="nc" id="L2310"> }</span>
<span class="fc" id="L2311"> return r;</span>
<span class="nc" id="L2312"> } catch (IOException e) {</span>
<span class="nc" id="L2313"> throw new GHException(&quot;Failed to retrieve post-commit hooks&quot;, e);</span>
}
}
@Override
public Iterator&lt;URL&gt; iterator() {
<span class="nc" id="L2319"> return getPostCommitHooks().iterator();</span>
}
@Override
public int size() {
<span class="fc" id="L2324"> return getPostCommitHooks().size();</span>
}
@Override
public boolean add(URL url) {
try {
<span class="nc" id="L2330"> createWebHook(url);</span>
<span class="nc" id="L2331"> return true;</span>
<span class="nc" id="L2332"> } catch (IOException e) {</span>
<span class="nc" id="L2333"> throw new GHException(&quot;Failed to update post-commit hooks&quot;, e);</span>
}
}
@Override
public boolean remove(Object url) {
try {
<span class="nc" id="L2340"> String _url = ((URL) url).toExternalForm();</span>
<span class="nc bnc" id="L2341" title="All 2 branches missed."> for (GHHook h : getHooks()) {</span>
<span class="nc bnc" id="L2342" title="All 4 branches missed."> if (h.getName().equals(&quot;web&quot;) &amp;&amp; h.getConfig().get(&quot;url&quot;).equals(_url)) {</span>
<span class="nc" id="L2343"> h.delete();</span>
<span class="nc" id="L2344"> return true;</span>
}
<span class="nc" id="L2346"> }</span>
<span class="nc" id="L2347"> return false;</span>
<span class="nc" id="L2348"> } catch (IOException e) {</span>
<span class="nc" id="L2349"> throw new GHException(&quot;Failed to update post-commit hooks&quot;, e);</span>
}
}
};
}
GHRepository wrap(GitHub root) {
<span class="fc" id="L2356"> this.root = root;</span>
<span class="fc bfc" id="L2357" title="All 4 branches covered."> if (root.isOffline() &amp;&amp; owner != null) {</span>
<span class="fc" id="L2358"> owner.wrapUp(root);</span>
}
<span class="fc bfc" id="L2360" title="All 2 branches covered."> if (source != null) {</span>
<span class="fc" id="L2361"> source.wrap(root);</span>
}
<span class="fc bfc" id="L2363" title="All 2 branches covered."> if (parent != null) {</span>
<span class="fc" id="L2364"> parent.wrap(root);</span>
}
<span class="fc" id="L2366"> return this;</span>
}
/**
* Gets branches by {@linkplain GHBranch#getName() their names}.
*
* @return the branches
* @throws IOException
* the io exception
*/
public Map&lt;String, GHBranch&gt; getBranches() throws IOException {
<span class="nc" id="L2377"> Map&lt;String, GHBranch&gt; r = new TreeMap&lt;String, GHBranch&gt;();</span>
<span class="nc" id="L2378"> for (GHBranch p : root.createRequest()</span>
<span class="nc" id="L2379"> .withUrlPath(getApiTailUrl(&quot;branches&quot;))</span>
<span class="nc" id="L2380"> .toIterable(GHBranch[].class, item -&gt; item.wrap(this))</span>
<span class="nc bnc" id="L2381" title="All 2 branches missed."> .toArray()) {</span>
<span class="nc" id="L2382"> r.put(p.getName(), p);</span>
}
<span class="nc" id="L2384"> return r;</span>
}
/**
* Gets branch.
*
* @param name
* the name
* @return the branch
* @throws IOException
* the io exception
*/
public GHBranch getBranch(String name) throws IOException {
<span class="fc" id="L2397"> return root.createRequest().withUrlPath(getApiTailUrl(&quot;branches/&quot; + name)).fetch(GHBranch.class).wrap(this);</span>
}
/**
* Gets milestones.
*
* @return the milestones
* @throws IOException
* the io exception
* @deprecated Use {@link #listMilestones(GHIssueState)}
*/
public Map&lt;Integer, GHMilestone&gt; getMilestones() throws IOException {
<span class="nc" id="L2409"> Map&lt;Integer, GHMilestone&gt; milestones = new TreeMap&lt;Integer, GHMilestone&gt;();</span>
<span class="nc bnc" id="L2410" title="All 2 branches missed."> for (GHMilestone m : listMilestones(GHIssueState.OPEN)) {</span>
<span class="nc" id="L2411"> milestones.put(m.getNumber(), m);</span>
<span class="nc" id="L2412"> }</span>
<span class="nc" id="L2413"> return milestones;</span>
}
/**
* Lists up all the milestones in this repository.
*
* @param state
* the state
* @return the paged iterable
*/
public PagedIterable&lt;GHMilestone&gt; listMilestones(final GHIssueState state) {
<span class="nc" id="L2424"> return root.createRequest()</span>
<span class="nc" id="L2425"> .with(&quot;state&quot;, state)</span>
<span class="nc" id="L2426"> .withUrlPath(getApiTailUrl(&quot;milestones&quot;))</span>
<span class="nc" id="L2427"> .toIterable(GHMilestone[].class, item -&gt; item.wrap(this));</span>
}
/**
* Gets milestone.
*
* @param number
* the number
* @return the milestone
* @throws IOException
* the io exception
*/
public GHMilestone getMilestone(int number) throws IOException {
<span class="fc" id="L2440"> GHMilestone m = milestones.get(number);</span>
<span class="pc bpc" id="L2441" title="1 of 2 branches missed."> if (m == null) {</span>
<span class="fc" id="L2442"> m = root.createRequest().withUrlPath(getApiTailUrl(&quot;milestones/&quot; + number)).fetch(GHMilestone.class);</span>
<span class="fc" id="L2443"> m.owner = this;</span>
<span class="fc" id="L2444"> m.root = root;</span>
<span class="fc" id="L2445"> milestones.put(m.getNumber(), m);</span>
}
<span class="fc" id="L2447"> return m;</span>
}
/**
* Gets file content.
*
* @param path
* the path
* @return the file content
* @throws IOException
* the io exception
*/
public GHContent getFileContent(String path) throws IOException {
<span class="fc" id="L2460"> return getFileContent(path, null);</span>
}
/**
* Gets file content.
*
* @param path
* the path
* @param ref
* the ref
* @return the file content
* @throws IOException
* the io exception
*/
public GHContent getFileContent(String path, String ref) throws IOException {
<span class="fc" id="L2475"> Requester requester = root.createRequest();</span>
<span class="fc" id="L2476"> String target = getApiTailUrl(&quot;contents/&quot; + path);</span>
<span class="fc" id="L2478"> return requester.with(&quot;ref&quot;, ref).withUrlPath(target).fetch(GHContent.class).wrap(this);</span>
}
/**
* Gets directory content.
*
* @param path
* the path
* @return the directory content
* @throws IOException
* the io exception
*/
public List&lt;GHContent&gt; getDirectoryContent(String path) throws IOException {
<span class="fc" id="L2491"> return getDirectoryContent(path, null);</span>
}
/**
* Gets directory content.
*
* @param path
* the path
* @param ref
* the ref
* @return the directory content
* @throws IOException
* the io exception
*/
public List&lt;GHContent&gt; getDirectoryContent(String path, String ref) throws IOException {
<span class="fc" id="L2506"> Requester requester = root.createRequest();</span>
<span class="fc bfc" id="L2507" title="All 2 branches covered."> while (path.endsWith(&quot;/&quot;)) {</span>
<span class="fc" id="L2508"> path = path.substring(0, path.length() - 1);</span>
}
<span class="fc" id="L2510"> String target = getApiTailUrl(&quot;contents/&quot; + path);</span>
<span class="fc" id="L2512"> return requester.with(&quot;ref&quot;, ref)</span>
<span class="fc" id="L2513"> .withUrlPath(target)</span>
<span class="fc" id="L2514"> .toIterable(GHContent[].class, item -&gt; item.wrap(this))</span>
<span class="fc" id="L2515"> .toList();</span>
}
/**
* https://developer.github.com/v3/repos/contents/#get-the-readme
*
* @return the readme
* @throws IOException
* the io exception
*/
public GHContent getReadme() throws IOException {
<span class="fc" id="L2526"> Requester requester = root.createRequest();</span>
<span class="fc" id="L2527"> return requester.withUrlPath(getApiTailUrl(&quot;readme&quot;)).fetch(GHContent.class).wrap(this);</span>
}
/**
* Creates a new content, or update an existing content.
*
* @return the gh content builder
*/
public GHContentBuilder createContent() {
<span class="fc" id="L2536"> return new GHContentBuilder(this);</span>
}
/**
* Use {@link #createContent()}.
*
* @param content
* the content
* @param commitMessage
* the commit message
* @param path
* the path
* @return the gh content update response
* @throws IOException
* the io exception
*/
@Deprecated
public GHContentUpdateResponse createContent(String content, String commitMessage, String path) throws IOException {
<span class="fc" id="L2554"> return createContent().content(content).message(commitMessage).path(path).commit();</span>
}
/**
* Use {@link #createContent()}.
*
* @param content
* the content
* @param commitMessage
* the commit message
* @param path
* the path
* @param branch
* the branch
* @return the gh content update response
* @throws IOException
* the io exception
*/
@Deprecated
public GHContentUpdateResponse createContent(String content, String commitMessage, String path, String branch)
throws IOException {
<span class="fc" id="L2575"> return createContent().content(content).message(commitMessage).path(path).branch(branch).commit();</span>
}
/**
* Use {@link #createContent()}.
*
* @param contentBytes
* the content bytes
* @param commitMessage
* the commit message
* @param path
* the path
* @return the gh content update response
* @throws IOException
* the io exception
*/
@Deprecated
public GHContentUpdateResponse createContent(byte[] contentBytes, String commitMessage, String path)
throws IOException {
<span class="nc" id="L2594"> return createContent().content(contentBytes).message(commitMessage).path(path).commit();</span>
}
/**
* Use {@link #createContent()}.
*
* @param contentBytes
* the content bytes
* @param commitMessage
* the commit message
* @param path
* the path
* @param branch
* the branch
* @return the gh content update response
* @throws IOException
* the io exception
*/
@Deprecated
public GHContentUpdateResponse createContent(byte[] contentBytes, String commitMessage, String path, String branch)
throws IOException {
<span class="nc" id="L2615"> return createContent().content(contentBytes).message(commitMessage).path(path).branch(branch).commit();</span>
}
/**
* Create milestone gh milestone.
*
* @param title
* the title
* @param description
* the description
* @return the gh milestone
* @throws IOException
* the io exception
*/
public GHMilestone createMilestone(String title, String description) throws IOException {
<span class="fc" id="L2630"> return root.createRequest()</span>
<span class="fc" id="L2631"> .method(&quot;POST&quot;)</span>
<span class="fc" id="L2632"> .with(&quot;title&quot;, title)</span>
<span class="fc" id="L2633"> .with(&quot;description&quot;, description)</span>
<span class="fc" id="L2634"> .withUrlPath(getApiTailUrl(&quot;milestones&quot;))</span>
<span class="fc" id="L2635"> .fetch(GHMilestone.class)</span>
<span class="fc" id="L2636"> .wrap(this);</span>
}
/**
* Add deploy key gh deploy key.
*
* @param title
* the title
* @param key
* the key
* @return the gh deploy key
* @throws IOException
* the io exception
*/
public GHDeployKey addDeployKey(String title, String key) throws IOException {
<span class="nc" id="L2651"> return root.createRequest()</span>
<span class="nc" id="L2652"> .method(&quot;POST&quot;)</span>
<span class="nc" id="L2653"> .with(&quot;title&quot;, title)</span>
<span class="nc" id="L2654"> .with(&quot;key&quot;, key)</span>
<span class="nc" id="L2655"> .withUrlPath(getApiTailUrl(&quot;keys&quot;))</span>
<span class="nc" id="L2656"> .fetch(GHDeployKey.class)</span>
<span class="nc" id="L2657"> .wrap(this);</span>
}
/**
* Gets deploy keys.
*
* @return the deploy keys
* @throws IOException
* the io exception
*/
public List&lt;GHDeployKey&gt; getDeployKeys() throws IOException {
<span class="nc" id="L2669"> return root.createRequest()</span>
<span class="nc" id="L2670"> .withUrlPath(getApiTailUrl(&quot;keys&quot;))</span>
<span class="nc" id="L2671"> .toIterable(GHDeployKey[].class, item -&gt; item.wrap(this))</span>
<span class="nc" id="L2672"> .toList();</span>
}
/**
* Forked repositories have a 'source' attribute that specifies the ultimate source of the forking chain.
*
* @return {@link GHRepository} that points to the root repository where this repository is forked (indirectly or
* directly) from. Otherwise null.
* @throws IOException
* the io exception
* @see #getParent() #getParent()
*/
public GHRepository getSource() throws IOException {
<span class="pc bpc" id="L2685" title="1 of 4 branches missed."> if (fork &amp;&amp; source == null) {</span>
<span class="fc" id="L2686"> populate();</span>
}
<span class="fc bfc" id="L2688" title="All 2 branches covered."> if (source == null) {</span>
<span class="fc" id="L2689"> return null;</span>
}
<span class="fc" id="L2692"> return source;</span>
}
/**
* Forked repositories have a 'parent' attribute that specifies the repository this repository is directly forked
* from. If we keep traversing {@link #getParent()} until it returns null, that is {@link #getSource()}.
*
* @return {@link GHRepository} that points to the repository where this repository is forked directly from.
* Otherwise null.
* @throws IOException
* the io exception
* @see #getSource() #getSource()
*/
public GHRepository getParent() throws IOException {
<span class="pc bpc" id="L2706" title="1 of 4 branches missed."> if (fork &amp;&amp; parent == null) {</span>
<span class="fc" id="L2707"> populate();</span>
}
<span class="fc bfc" id="L2710" title="All 2 branches covered."> if (parent == null) {</span>
<span class="fc" id="L2711"> return null;</span>
}
<span class="fc" id="L2713"> return parent;</span>
}
/**
* Subscribes to this repository to get notifications.
*
* @param subscribed
* the subscribed
* @param ignored
* the ignored
* @return the gh subscription
* @throws IOException
* the io exception
*/
public GHSubscription subscribe(boolean subscribed, boolean ignored) throws IOException {
<span class="fc" id="L2728"> return root.createRequest()</span>
<span class="fc" id="L2729"> .method(&quot;PUT&quot;)</span>
<span class="fc" id="L2730"> .with(&quot;subscribed&quot;, subscribed)</span>
<span class="fc" id="L2731"> .with(&quot;ignored&quot;, ignored)</span>
<span class="fc" id="L2732"> .withUrlPath(getApiTailUrl(&quot;subscription&quot;))</span>
<span class="fc" id="L2733"> .fetch(GHSubscription.class)</span>
<span class="fc" id="L2734"> .wrapUp(this);</span>
}
/**
* Returns the current subscription.
*
* @return null if no subscription exists.
* @throws IOException
* the io exception
*/
public GHSubscription getSubscription() throws IOException {
try {
<span class="pc" id="L2746"> return root.createRequest()</span>
<span class="fc" id="L2747"> .withUrlPath(getApiTailUrl(&quot;subscription&quot;))</span>
<span class="nc" id="L2748"> .fetch(GHSubscription.class)</span>
<span class="nc" id="L2749"> .wrapUp(this);</span>
<span class="fc" id="L2750"> } catch (FileNotFoundException e) {</span>
<span class="fc" id="L2751"> return null;</span>
}
}
/**
* List contributors paged iterable.
*
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;Contributor&gt; listContributors() throws IOException {
<span class="fc" id="L2763"> return root.createRequest()</span>
<span class="fc" id="L2764"> .withUrlPath(getApiTailUrl(&quot;contributors&quot;))</span>
<span class="fc" id="L2765"> .toIterable(Contributor[].class, item -&gt; item.wrapUp(root));</span>
}
/**
* The type Contributor.
*/
<span class="fc" id="L2771"> public static class Contributor extends GHUser {</span>
private int contributions;
/**
* Gets contributions.
*
* @return the contributions
*/
public int getContributions() {
<span class="fc" id="L2780"> return contributions;</span>
}
@Override
public int hashCode() {
// We ignore contributions in the calculation
<span class="nc" id="L2786"> return super.hashCode();</span>
}
@Override
public boolean equals(Object obj) {
// We ignore contributions in the calculation
<span class="nc" id="L2792"> return super.equals(obj);</span>
}
}
/**
* Returns the statistics for this repository.
*
* @return the statistics
*/
public GHRepositoryStatistics getStatistics() {
// TODO: Use static object and introduce refresh() method,
// instead of returning new object each time.
<span class="fc" id="L2804"> return new GHRepositoryStatistics(this);</span>
}
/**
* Create a project for this repository.
*
* @param name
* the name
* @param body
* the body
* @return the gh project
* @throws IOException
* the io exception
*/
public GHProject createProject(String name, String body) throws IOException {
<span class="nc" id="L2819"> return root.createRequest()</span>
<span class="nc" id="L2820"> .method(&quot;POST&quot;)</span>
<span class="nc" id="L2821"> .withPreview(INERTIA)</span>
<span class="nc" id="L2822"> .with(&quot;name&quot;, name)</span>
<span class="nc" id="L2823"> .with(&quot;body&quot;, body)</span>
<span class="nc" id="L2824"> .withUrlPath(getApiTailUrl(&quot;projects&quot;))</span>
<span class="nc" id="L2825"> .fetch(GHProject.class)</span>
<span class="nc" id="L2826"> .wrap(this);</span>
}
/**
* Returns the projects for this repository.
*
* @param status
* The status filter (all, open or closed).
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHProject&gt; listProjects(final GHProject.ProjectStateFilter status) throws IOException {
<span class="nc" id="L2839"> return root.createRequest()</span>
<span class="nc" id="L2840"> .withPreview(INERTIA)</span>
<span class="nc" id="L2841"> .with(&quot;state&quot;, status)</span>
<span class="nc" id="L2842"> .withUrlPath(getApiTailUrl(&quot;projects&quot;))</span>
<span class="nc" id="L2843"> .toIterable(GHProject[].class, item -&gt; item.wrap(this));</span>
}
/**
* Returns open projects for this repository.
*
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHProject&gt; listProjects() throws IOException {
<span class="nc" id="L2854"> return listProjects(GHProject.ProjectStateFilter.OPEN);</span>
}
/**
* Render a Markdown document.
* &lt;p&gt;
* In {@linkplain MarkdownMode#GFM GFM mode}, issue numbers and user mentions are linked accordingly.
*
* @param text
* the text
* @param mode
* the mode
* @return the reader
* @throws IOException
* the io exception
* @see GitHub#renderMarkdown(String) GitHub#renderMarkdown(String)
*/
public Reader renderMarkdown(String text, MarkdownMode mode) throws IOException {
<span class="fc" id="L2872"> return new InputStreamReader(</span>
<span class="fc" id="L2873"> root.createRequest()</span>
<span class="fc" id="L2874"> .method(&quot;POST&quot;)</span>
<span class="fc" id="L2875"> .with(&quot;text&quot;, text)</span>
<span class="pc bpc" id="L2876" title="1 of 2 branches missed."> .with(&quot;mode&quot;, mode == null ? null : mode.toString())</span>
<span class="fc" id="L2877"> .with(&quot;context&quot;, getFullName())</span>
<span class="fc" id="L2878"> .withUrlPath(&quot;/markdown&quot;)</span>
<span class="fc" id="L2879"> .fetchStream(Requester::copyInputStream),</span>
&quot;UTF-8&quot;);
}
/**
* List all the notifications in a repository for the current user.
*
* @return the gh notification stream
*/
public GHNotificationStream listNotifications() {
<span class="nc" id="L2889"> return new GHNotificationStream(root, getApiTailUrl(&quot;/notifications&quot;));</span>
}
/**
* &lt;a href=
* &quot;https://developer.github.com/v3/repos/traffic/#views&quot;&gt;https://developer.github.com/v3/repos/traffic/#views&lt;/a&gt;
*
* @return the view traffic
* @throws IOException
* the io exception
*/
public GHRepositoryViewTraffic getViewTraffic() throws IOException {
<span class="fc" id="L2901"> return root.createRequest().withUrlPath(getApiTailUrl(&quot;/traffic/views&quot;)).fetch(GHRepositoryViewTraffic.class);</span>
}
/**
* &lt;a href=
* &quot;https://developer.github.com/v3/repos/traffic/#clones&quot;&gt;https://developer.github.com/v3/repos/traffic/#clones&lt;/a&gt;
*
* @return the clone traffic
* @throws IOException
* the io exception
*/
public GHRepositoryCloneTraffic getCloneTraffic() throws IOException {
<span class="fc" id="L2913"> return root.createRequest().withUrlPath(getApiTailUrl(&quot;/traffic/clones&quot;)).fetch(GHRepositoryCloneTraffic.class);</span>
}
@Override
public int hashCode() {
<span class="nc" id="L2918"> return (&quot;Repository:&quot; + getOwnerName() + &quot;:&quot; + name).hashCode();</span>
}
@Override
public boolean equals(Object obj) {
<span class="pc bpc" id="L2923" title="1 of 2 branches missed."> if (obj instanceof GHRepository) {</span>
<span class="fc" id="L2924"> GHRepository that = (GHRepository) obj;</span>
<span class="pc bpc" id="L2925" title="1 of 4 branches missed."> return this.getOwnerName().equals(that.getOwnerName()) &amp;&amp; this.name.equals(that.name);</span>
}
<span class="nc" id="L2927"> return false;</span>
}
String getApiTailUrl(String tail) {
<span class="fc bfc" id="L2931" title="All 4 branches covered."> if (tail.length() &gt; 0 &amp;&amp; !tail.startsWith(&quot;/&quot;)) {</span>
<span class="fc" id="L2932"> tail = '/' + tail;</span>
}
<span class="fc" id="L2934"> return &quot;/repos/&quot; + getOwnerName() + &quot;/&quot; + name + tail;</span>
}
/**
* Get all issue events for this repository. See
* https://developer.github.com/v3/issues/events/#list-events-for-a-repository
*
* @return the paged iterable
* @throws IOException
* the io exception
*/
public PagedIterable&lt;GHIssueEvent&gt; listIssueEvents() throws IOException {
<span class="fc" id="L2946"> return root.createRequest()</span>
<span class="fc" id="L2947"> .withUrlPath(getApiTailUrl(&quot;issues/events&quot;))</span>
<span class="fc" id="L2948"> .toIterable(GHIssueEvent[].class, item -&gt; item.wrapUp(root));</span>
}
/**
* Get a single issue event. See https://developer.github.com/v3/issues/events/#get-a-single-event
*
* @param id
* the id
* @return the issue event
* @throws IOException
* the io exception
*/
public GHIssueEvent getIssueEvent(long id) throws IOException {
<span class="fc" id="L2961"> return root.createRequest()</span>
<span class="fc" id="L2962"> .withUrlPath(getApiTailUrl(&quot;issues/events/&quot; + id))</span>
<span class="fc" id="L2963"> .fetch(GHIssueEvent.class)</span>
<span class="fc" id="L2964"> .wrapUp(root);</span>
}
/**
* Lists all the workflows of this repository.
*
* @return the paged iterable
*/
public PagedIterable&lt;GHWorkflow&gt; listWorkflows() {
<span class="fc" id="L2973"> return new GHWorkflowsIterable(this);</span>
}
/**
* Gets a workflow by id.
*
* @param id
* the id of the workflow run
* @return the workflow run
* @throws IOException
* the io exception
*/
public GHWorkflow getWorkflow(long id) throws IOException {
<span class="fc" id="L2986"> return getWorkflow(String.valueOf(id));</span>
}
/**
* Gets a workflow by name of the file.
*
* @param nameOrId
* either the name of the file (e.g. my-workflow.yml) or the id as a string
* @return the workflow run
* @throws IOException
* the io exception
*/
public GHWorkflow getWorkflow(String nameOrId) throws IOException {
<span class="fc" id="L2999"> return root.createRequest()</span>
<span class="fc" id="L3000"> .withUrlPath(getApiTailUrl(&quot;actions/workflows&quot;), nameOrId)</span>
<span class="fc" id="L3001"> .fetch(GHWorkflow.class)</span>
<span class="fc" id="L3002"> .wrapUp(this);</span>
}
/**
* Retrieves workflow runs.
*
* @return the workflow run query builder
*/
public GHWorkflowRunQueryBuilder queryWorkflowRuns() {
<span class="fc" id="L3011"> return new GHWorkflowRunQueryBuilder(this);</span>
}
/**
* Gets a workflow run.
*
* @param id
* the id of the workflow run
* @return the workflow run
* @throws IOException
* the io exception
*/
public GHWorkflowRun getWorkflowRun(long id) throws IOException {
<span class="fc" id="L3024"> return root.createRequest()</span>
<span class="fc" id="L3025"> .withUrlPath(getApiTailUrl(&quot;actions/runs&quot;), String.valueOf(id))</span>
<span class="fc" id="L3026"> .fetch(GHWorkflowRun.class)</span>
<span class="fc" id="L3027"> .wrapUp(this);</span>
}
/**
* Lists all the artifacts of this repository.
*
* @return the paged iterable
*/
public PagedIterable&lt;GHArtifact&gt; listArtifacts() {
<span class="fc" id="L3036"> return new GHArtifactsIterable(this, root.createRequest().withUrlPath(getApiTailUrl(&quot;actions/artifacts&quot;)));</span>
}
/**
* Gets an artifact by id.
*
* @param id
* the id of the artifact
* @return the artifact
* @throws IOException
* the io exception
*/
public GHArtifact getArtifact(long id) throws IOException {
<span class="fc" id="L3049"> return root.createRequest()</span>
<span class="fc" id="L3050"> .withUrlPath(getApiTailUrl(&quot;actions/artifacts&quot;), String.valueOf(id))</span>
<span class="fc" id="L3051"> .fetch(GHArtifact.class)</span>
<span class="fc" id="L3052"> .wrapUp(this);</span>
}
/**
* Gets a job from a workflow run by id.
*
* @param id
* the id of the job
* @return the job
* @throws IOException
* the io exception
*/
public GHWorkflowJob getWorkflowJob(long id) throws IOException {
<span class="fc" id="L3065"> return root.createRequest()</span>
<span class="fc" id="L3066"> .withUrlPath(getApiTailUrl(&quot;/actions/jobs/&quot;), String.valueOf(id))</span>
<span class="fc" id="L3067"> .fetch(GHWorkflowJob.class)</span>
<span class="fc" id="L3068"> .wrapUp(this);</span>
}
// Only used within listTopics().
private static class Topics {
public List&lt;String&gt; names;
}
/**
* Return the topics for this repository. See
* https://developer.github.com/v3/repos/#list-all-topics-for-a-repository
*
* @return the list
* @throws IOException
* the io exception
*/
public List&lt;String&gt; listTopics() throws IOException {
<span class="fc" id="L3085"> Topics topics = root.createRequest()</span>
<span class="fc" id="L3086"> .withPreview(MERCY)</span>
<span class="fc" id="L3087"> .withUrlPath(getApiTailUrl(&quot;topics&quot;))</span>
<span class="fc" id="L3088"> .fetch(Topics.class);</span>
<span class="fc" id="L3089"> return topics.names;</span>
}
/**
* Set the topics for this repository. See
* https://developer.github.com/v3/repos/#replace-all-topics-for-a-repository
*
* @param topics
* the topics
* @throws IOException
* the io exception
*/
public void setTopics(List&lt;String&gt; topics) throws IOException {
<span class="fc" id="L3102"> root.createRequest()</span>
<span class="fc" id="L3103"> .method(&quot;PUT&quot;)</span>
<span class="fc" id="L3104"> .with(&quot;names&quot;, topics)</span>
<span class="fc" id="L3105"> .withPreview(MERCY)</span>
<span class="fc" id="L3106"> .withUrlPath(getApiTailUrl(&quot;topics&quot;))</span>
<span class="fc" id="L3107"> .send();</span>
<span class="fc" id="L3108"> }</span>
/**
* Create a tag. See https://developer.github.com/v3/git/tags/#create-a-tag-object
*
* @param tag
* The tag's name.
* @param message
* The tag message.
* @param object
* The SHA of the git object this is tagging.
* @param type
* The type of the object we're tagging: &quot;commit&quot;, &quot;tree&quot; or &quot;blob&quot;.
* @return The newly created tag.
* @throws java.io.IOException
* The IO exception.
*/
public GHTagObject createTag(String tag, String message, String object, String type) throws IOException {
<span class="fc" id="L3126"> return root.createRequest()</span>
<span class="fc" id="L3127"> .method(&quot;POST&quot;)</span>
<span class="fc" id="L3128"> .with(&quot;tag&quot;, tag)</span>
<span class="fc" id="L3129"> .with(&quot;message&quot;, message)</span>
<span class="fc" id="L3130"> .with(&quot;object&quot;, object)</span>
<span class="fc" id="L3131"> .with(&quot;type&quot;, type)</span>
<span class="fc" id="L3132"> .withUrlPath(getApiTailUrl(&quot;git/tags&quot;))</span>
<span class="fc" id="L3133"> .fetch(GHTagObject.class)</span>
<span class="fc" id="L3134"> .wrap(this);</span>
}
/**
* Streams a zip archive of the repository, optionally at a given &lt;code&gt;ref&lt;/code&gt;.
*
* @param &lt;T&gt;
* the type of result
* @param streamFunction
* The {@link InputStreamFunction} that will process the stream
* @param ref
* if &lt;code&gt;null&lt;/code&gt; the repository's default branch, usually &lt;code&gt;master&lt;/code&gt;,
* @throws IOException
* The IO exception.
* @return the result of reading the stream.
*/
public &lt;T&gt; T readZip(InputStreamFunction&lt;T&gt; streamFunction, String ref) throws IOException {
<span class="fc" id="L3151"> return downloadArchive(&quot;zip&quot;, ref, streamFunction);</span>
}
/**
* Streams a tar archive of the repository, optionally at a given &lt;code&gt;ref&lt;/code&gt;.
*
* @param &lt;T&gt;
* the type of result
* @param streamFunction
* The {@link InputStreamFunction} that will process the stream
* @param ref
* if &lt;code&gt;null&lt;/code&gt; the repository's default branch, usually &lt;code&gt;master&lt;/code&gt;,
* @throws IOException
* The IO exception.
* @return the result of reading the stream.
*/
public &lt;T&gt; T readTar(InputStreamFunction&lt;T&gt; streamFunction, String ref) throws IOException {
<span class="fc" id="L3168"> return downloadArchive(&quot;tar&quot;, ref, streamFunction);</span>
}
private &lt;T&gt; T downloadArchive(@Nonnull String type,
@CheckForNull String ref,
@Nonnull InputStreamFunction&lt;T&gt; streamFunction) throws IOException {
<span class="fc" id="L3174"> requireNonNull(streamFunction, &quot;Sink must not be null&quot;);</span>
<span class="fc" id="L3175"> String tailUrl = getApiTailUrl(type + &quot;ball&quot;);</span>
<span class="pc bpc" id="L3176" title="1 of 2 branches missed."> if (ref != null) {</span>
<span class="nc" id="L3177"> tailUrl += &quot;/&quot; + ref;</span>
}
<span class="fc" id="L3179"> final Requester builder = root.createRequest().method(&quot;GET&quot;).withUrlPath(tailUrl);</span>
<span class="fc" id="L3180"> return builder.fetchStream(streamFunction);</span>
}
/**
* Populate this object.
*
* @throws java.io.IOException
* The IO exception
*/
void populate() throws IOException {
<span class="fc bfc" id="L3190" title="All 2 branches covered."> if (root.isOffline()) {</span>
<span class="fc" id="L3191"> return; // can't populate if the root is offline</span>
}
<span class="fc" id="L3194"> final URL url = requireNonNull(getUrl(), &quot;Missing instance URL!&quot;);</span>
try {
// IMPORTANT: the url for repository records does not reliably point to the API url.
// There is bug in Push event payloads that returns the wrong url.
// All other occurrences of &quot;url&quot; take the form &quot;https://api.github.com/...&quot;.
// For Push event repository records, they take the form &quot;https://github.com/{fullName}&quot;.
<span class="fc" id="L3201"> root.createRequest()</span>
<span class="fc" id="L3202"> .withPreview(BAPTISTE)</span>
<span class="fc" id="L3203"> .withPreview(NEBULA)</span>
<span class="fc" id="L3204"> .setRawUrlPath(url.toString())</span>
<span class="fc" id="L3205"> .fetchInto(this)</span>
<span class="fc" id="L3206"> .wrap(root);</span>
<span class="fc" id="L3207"> } catch (HttpException e) {</span>
<span class="pc bpc" id="L3208" title="1 of 2 branches missed."> if (e.getCause() instanceof JsonParseException) {</span>
<span class="fc" id="L3209"> root.createRequest()</span>
<span class="fc" id="L3210"> .withPreview(BAPTISTE)</span>
<span class="fc" id="L3211"> .withPreview(NEBULA)</span>
<span class="fc" id="L3212"> .withUrlPath(&quot;/repos/&quot; + full_name)</span>
<span class="fc" id="L3213"> .fetchInto(this)</span>
<span class="fc" id="L3214"> .wrap(root);</span>
} else {
<span class="nc" id="L3216"> throw e;</span>
}
<span class="fc" id="L3218"> }</span>
<span class="fc" id="L3219"> }</span>
/**
* A {@link GHRepositoryBuilder} that allows multiple properties to be updated per request.
*
* Consumer must call {@link #done()} to commit changes.
*/
@BetaApi
@Deprecated
public static class Updater extends GHRepositoryBuilder&lt;Updater&gt; {
protected Updater(@Nonnull GHRepository repository) {
<span class="fc" id="L3230"> super(Updater.class, repository.root, null);</span>
// even when we don't change the name, we need to send it in
// this requirement may be out-of-date, but we do not want to break it
<span class="fc" id="L3233"> requester.with(&quot;name&quot;, repository.name);</span>
<span class="fc" id="L3235"> requester.method(&quot;PATCH&quot;).withUrlPath(repository.getApiTailUrl(&quot;&quot;));</span>
<span class="fc" id="L3236"> }</span>
}
/**
* A {@link GHRepositoryBuilder} that allows multiple properties to be updated per request.
*
* Consumer must call {@link #done()} to commit changes.
*/
@BetaApi
@Deprecated
public static class Setter extends GHRepositoryBuilder&lt;GHRepository&gt; {
protected Setter(@Nonnull GHRepository repository) {
<span class="fc" id="L3248"> super(GHRepository.class, repository.root, null);</span>
// even when we don't change the name, we need to send it in
// this requirement may be out-of-date, but we do not want to break it
<span class="fc" id="L3251"> requester.with(&quot;name&quot;, repository.name);</span>
<span class="fc" id="L3253"> requester.method(&quot;PATCH&quot;).withUrlPath(repository.getApiTailUrl(&quot;&quot;));</span>
<span class="fc" id="L3254"> }</span>
}
}
</pre><div class="footer"><span class="right">Created with <a href="http://www.jacoco.org/jacoco">JaCoCo</a> 0.8.6.202009150832</span></div></body></html>
Reference in New Issue View Git Blame Copy Permalink