NAME

Net::GitHub::V3::Repos - GitHub Repos API

SYNOPSIS


            
              
              use Net::GitHub::V3;
my $gh = Net::GitHub::V3->new; # read L<Net::GitHub::V3> to set right authentication info
my $repos = $gh->repos;
# set :user/:repo for simple calls
$repos->set_default_user_repo('fayland', 'perl-net-github');
my @contributors = $repos->contributors; # don't need pass user and repos

DESCRIPTION

METHODS

Repos

http://developer.github.com/v3/repos/

list

list_all


            
              
              # All public repositories on Github
my @rp = $repos->list_all;
# starting at id 500
my @rp = $repos->list_all(500);

list_user

list_org


            
              
              my @rp = $repos->list; # or my $rp = $repos->list;
my @rp = $repos->list({
    type => 'private'
    sort => 'updated'
});
my @rp = $repos->list_user('c9s');
my @rp = $repos->list_user('c9s', {
    type => 'member'
});
my @rp = $repos->list_org('perlchina');
my @rp = $repos->list_org('perlchina', 'public');

next_repo, next_all_repo, next_user_repo, next_org_repo


            
              
              # Iterate over your repositories
while (my $repo = $repos->next_repo) { ...; }
# Iterate over all public repositories
while (my $repo = $repos->next_all_repo(500)) { ...; }
# Iterate over repositories of another user
while (my $repo = $repos->next_user_repo('c9s')) { ...; }
# Iterate over repositories of an organisation
while (my $repo = $repos->next_org_repo('perlchina','public')) { ...; }

create


            
              
              # create for yourself
my $rp = $repos->create( {
    "name" => "Hello-World",
    "description" => "This is your first repo",
    "homepage" => "https://github.com"
} );
# create for organization
my $rp = $repos->create( {
    "org"  => "perlchina", ## the organization
    "name" => "Hello-World",
    "description" => "This is your first repo",
    "homepage" => "https://github.com"
} );

get


            
              
              my $rp = $repos->get('fayland', 'perl-net-github');

To ease the keyboard, we provied two ways to call any method which starts with :user/:repo

1. SET user/repos before call methods below


            
              
              $gh->set_default_user_repo('fayland', 'perl-net-github'); # take effects for all $gh->
$repos->set_default_user_repo('fayland', 'perl-net-github'); # only take effect to $gh->repos
my @contributors = $repos->contributors;

2. If it is just for once, we can pass :user, :repo before any arguments


            
              
              my @contributors = $repos->contributors($user, $repo);

update


            
              
              $repos->update({ homepage => 'https://metacpan.org/module/Net::GitHub' });

delete


            
              
              $repos->delete();

contributors

languages

teams

tags

contributors


            
              
              my @contributors = $repos->contributors;
my @languages = $repos->languages;
my @teams = $repos->teams;
my @tags = $repos->tags;
my @branches = $repos->branches;
my $branch = $repos->branch('master');
while (my $contributor = $repos->next_contributor) { ...; }
while (my $team = $repos->next_team) { ... ; }
while (my $tags = $repos->next_tag) { ... ; }

Repo Collaborators API

http://developer.github.com/v3/repos/collaborators/

collaborators

is_collaborator

add_collaborator

delete_collaborator


            
              
              my @collaborators = $repos->collaborators;
while (my $collaborator = $repos->next_collaborator) { ...; }
my $is = $repos->is_collaborator('fayland');
$repos->add_collaborator('fayland');
$repos->delete_collaborator('fayland');

Commits API

http://developer.github.com/v3/repos/commits/

commits

commit


            
              
              my @commits = $repos->commits;
my @commits = $repos->commits({
    author => 'fayland'
});
my $commit  = $repos->commit($sha);
while (my $commit = $repos->next_commit({...})) { ...; }

comments

commit_comments

create_comment

comment

update_comment

delete_comment


            
              
              my @comments = $repos->comments;
while (my $comment = $repos->next_comment) { ...; }
my @comments = $repos->commit_comments($sha);
while (my $comment = $repos->next_commit_comment($sha)) { ...; }
my $comment  = $repos->create_comment($sha, {
    "body" => "Nice change",
    "commit_id" => "6dcb09b5b57875f334f61aebed695e2e4193db5e",
    "line" => 1,
    "path" => "file1.txt",
    "position" => 4
});
my $comment = $repos->comment($comment_id);
my $comment = $repos->update_comment($comment_id, {
    "body" => "Nice change"
});
my $st = $repos->delete_comment($comment_id);

compare_commits


            
              
              my $diffs = $repos->compare_commits($base, $head);

Forks API

http://developer.github.com/v3/repos/forks/

forks

create_fork


            
              
              my @forks = $repos->forks;
while (my $fork = $repos->next_fork) { ...; }
my $fork = $repos->create_fork;
my $fork = $repos->create_fork($org);

Repos Deploy Keys API

http://developer.github.com/v3/repos/keys/

keys

key

create_key

update_key

delete_key


            
              
              my @keys = $repos->keys;
while (my $key = $repos->next_key) { ...; }
my $key  = $repos->key($key_id); # get key
$repos->create_key( {
    title => 'title',
    key   => $key
} );
$repos->update_key($key_id, {
    title => $title,
    key   => $key
});
$repos->delete_key($key_id);

Repo Watching API

http://developer.github.com/v3/repos/watching/

watchers


            
              
              my @watchers = $repos->watchers;
while (my $watcher = $repos->next_watcher) { ...; }

watched


            
              
              my @repos = $repos->watched; # what I watched
my @repos = $repos->watched('c9s');

is_watching


            
              
              my $is_watching = $repos->is_watching;
my $is_watching = $repos->is_watching('fayland', 'perl-net-github');

watch

unwatch


            
              
              my $st = $repos->watch();
my $st = $repos->watch('fayland', 'perl-net-github');
my $st = $repos->unwatch();
my $st = $repos->unwatch('fayland', 'perl-net-github');

Subscriptions

Github changed the ideas of Watchers (stars) and Subscriptions (new watchers).


            
              
              https://github.com/blog/1204-notifications-stars

The Watchers code in this module predates the terminology change, so the new Watcher methods use the GitHub 'subscription' terminology.

subscribers

Returns a list of subscriber data hashes.

next_subscriber

Returns the next subscriber in the list, or undef if there are no more subscribers.

is_subscribed

Returns true or false if you are subscribed


            
              
              $repos->is_subscribed();
$repos->is_subscribed('fayland','perl-net-github');

subscription

Returns more information about your subscription to a repo. is_subscribed is a shortcut to calling this and checking for subscribed => 1.

subscribe

Required argument telling github if you want to subscribe or if you want to ignore mentions. If you want to change from subscribed to ignores you need to unsubscribe first.


            
              
              $repos->subscribe('fayland','perl-net-github', { subscribed => 1 })
$repos->subscribe('fayland','perl-net-github', { ignored => 1 })

unsubscribe


            
              
              $repos->unsubscribe('fayland','perl-net-github');

Hooks API

http://developer.github.com/v3/repos/hooks/

hooks

next_hook

hook

create_hook

update_hook

test_hook

delete_hook


            
              
              my @hooks = $repos->hooks;
while (my $hook = $repos->next_hook) { ...; }
my $hook  = $repos->hook($hook_id);
my $hook  = $repos->create_hook($hook_hash);
my $hook  = $repos->update_hook($hook_id, $new_hook_hash);
my $st    = $repos->test_hook($hook_id);
my $st    = $repos->delete_hook($hook_id);

Repo Merging API

http://developer.github.com/v3/repos/merging/

merges


            
              
              my $status = $repos->merges( {
    "base" => "master",
    "head" => "cool_feature",
    "commit_message" => "Shipped cool_feature!"
} );

Repo Statuses API

http://developer.github.com/v3/repos/statuses/

list_statuses


            
              
              $gh->set_default_user_repo('fayland', 'perl-net-github');
my @statuses = $repos->lists_statuses($sha);

Or:


            
              
              my @statuses = $repos->list_statuses('fayland', 'perl-net-github', $sha);

next_status


            
              
              while (my $status = $repos->next_status($sha)) { ...; }

create_status


            
              
              $gh->set_default_user_repo('fayland', 'perl-net-github');
my %payload = {
    "state"       => "success",
    "target_url"  => "https://example.com/build/status",
    "description" => "The build succeeded!",
    "context"     => "build/status"
};
my $status = $repos->create_status($sha, %payload);

Or:


            
              
              my %payload = {
    "state"       => "success",
    "target_url"  => "https://example.com/build/status",
    "description" => "The build succeeded!",
    "context"     => "build/status"
};
my $status = $repos->create_status(
    'fayland', 'perl-net-github', $sha, %payload
);

Repo Releases API

http://developer.github.com/v3/repos/releases/

releases


            
              
              my @releases = $repos->releases();
while (my $release = $repos->next_release) { ...; }

release


            
              
              my $release = $repos->release($release_id);

create_release


            
              
              my $release = $repos->create_release({
  "tag_name" => "v1.0.0",
  "target_commitish" => "master",
  "name" => "v1.0.0",
  "body" => "Description of the release",
  "draft" => \1,
});

update_release


            
              
              my $release = $repos->update_release($release_id, {
  "tag_name" => "v1.0.0",
  "target_commitish" => "master",
  "name" => "v1.0.0",
  "body" => "Description of the release",
});

delete_release


            
              
              $repos->delete_release($release_id);

release_assets


            
              
              my @release_assets = $repos->release_assets($release_id);
while (my $asset = $repos->next_release_asset($release_id)) { ...; }

upload_asset


            
              
              my $asset = $repos->upload_asset($release_id, $name, $content_type, $file_content);

Check examples/upload_asset.pl for a working example.

release_asset


            
              
              my $release_asset = $repos->release_asset($release_id, $asset_id);

update_release_asset


            
              
              my $release_asset = $repos->update_release_asset($release_id, $asset_id, {
    name" => "foo-1.0.0-osx.zip",
    "label" => "Mac binary"
});

delete_release_asset


            
              
              my $ok = $repos->delete_release_asset($release_id, $asset_id);

Contents API

https://developer.github.com/v3/repos/contents/

get_content

Gets the contents of a file or directory in a repository. Specify the file path or directory in $path. If you omit $path, you will receive the contents of all files in the repository.


            
              
              my $response = $repos->get_content( $owner, $repo, $path )
    or
    $repos->get_content(
        { owner => $owner,  repo => $repo, path => $path },
     )
    or
    $repos->get_content(
        { owner => $owner,  repo => $repo, path => $path },
        { ref => 'feature-branch' }
     )

Repo Deployment API

http://developer.github.com/v3/repos/deployments/

list_deployments


            
              
              my $response = $repos->list_deployments( $owner, $repo, {
    'ref' => 'feature-branch',
});

next_deployment


            
              
              while (my $deployment = $repos->next_deployment( $owner, $repo, {
    'ref' => 'feature-branch',
}) { ...; }

create_deployment


            
              
              my $response = $repos->create_deployment( $owner, $repo, {
  "ref" => 'feature-branch',
  "description" => "deploying my new feature",
});

list_deployment_statuses


            
              
              my $response = $repos->list_deployment_statuses( $owner, $repo, $deployment_id );

next_deployment_status


            
              
              while (my $status = next_deployment_status($o,$r,$id)) { ...; }

create_deployment_status


            
              
              my $response = $repos->create_deployment_status( $owner, $repo, $deployment_id, {
    "state": "success",
    "target_url": "https://example.com/deployment/42/output",
    "description": "Deployment finished successfully."
});

Repo Statistics API

http://developer.github.com/v3/repos/statistics/

contributor stats

commit activity

code frequency

participation

punch card


            
              
              my $contributor_stats   = $repos->contributor_stats($owner, $repo);
my $commit_activity     = $repos->commit_activity($owner, $repo);
my $code_freq           = $repos->code_frequency($owner, $repo);
my $participation       = $repos->participation($owner, $repo);
my $punch_card          = $repos->punch_card($owner, $repo);

Branch Protection API

https://docs.github.com/en/rest/branches/branch-protection

branch_protection


            
              
              my $protection = $repos->branch_protection('fayland', 'perl-net-github', 'master');

delete_branch_protection


            
              
              $repos->delete_branch_protection('fayland', 'perl-net-github', 'master');

update_branch_protection


            
              
              $repos->update_branch_protection('fayland', 'perl-net-github', 'master', {
    allow_deletions => \0,
    allow_force_pushes => \0,
    block_creations => \1,
    enforce_admins => \1,
    required_conversation_resolution => \1,
    required_linear_history => \0,
    required_pull_request_reviews => {
        dismiss_stale_reviews => \1,
        require_code_owner_reviews => \1,
        required_approving_review_count => 2,
    },
    required_status_checks => {
        strict => \1,
        contexts => []
    },
    restrictions => undef,
});

AUTHOR & COPYRIGHT & LICENSE

Refer Net::GitHub

To install Net::GitHub, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Net::GitHub

CPAN shell

perl -MCPAN -e shell
install Net::GitHub

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)