File Coverage

blib/lib/Github/Backup.pm

Criterion	Covered	Total	%
statement	62	117	52.9
branch	17	62	27.4
condition	10	15	66.6
subroutine	15	20	75.0
pod	4	5	80.0
total	108	219	49.3

package Github::Backup;

use strict;
use warnings;

use Carp qw(croak);
use Data::Dumper;
use Git::Repository;
use Hook::Output::Tiny;
use File::Copy;
use File::Path;
use JSON;
use LWP::UserAgent;
use Moo;
use Pithub;

use namespace::clean;

our $VERSION = '1.04';

# external

has api_user => (
    is => 'rw',
);
has _clean => (
    # used to clean up test backup directories
    is => 'rw',
);
has dir => (
    is => 'rw',
);
has forks => (
    is => 'rw',
);
has token => (
    is => 'rw',
);
has proxy => (
    is => 'rw',
);
has user => (
    is => 'rw',
);
has limit => (
    is => 'rw',
);

# internal

has gh => (
    # Pithub object
    is => 'rw',
);
has stg => (
    # staging dir
    is => 'rw',
);

sub BUILD {
    my ($self) = @_;

    if (! $self->token){
        $self->token($ENV{GITHUB_TOKEN}) if $ENV{GITHUB_TOKEN};
    }

    for my $key (qw/api_user token dir/){
        if (! $self->{$key}){
            croak "ERROR: Missing mandatory parameter [$key].\n";
        }
    }

    my $ua = LWP::UserAgent->new;

    if ($self->proxy){
        $ENV{http_proxy} = $self->proxy;
        $ENV{https_proxy} = $self->proxy;

        $ua->env_proxy;
    }

    my $gh = Pithub->new(
        ua => $ua,
        user => $self->api_user,
        token => $self->token,
        auto_pagination => 1,
    );

    $self->stg($self->dir . '.stg');
    $self->gh($gh);

    $self->user($self->api_user) if ! defined $self->user;

    if (-d $self->stg){
        rmtree $self->stg or die "can't remove the old staging directory...$!";
    }

    mkdir $self->stg or die "can't create the backup staging directory...$!\n";
}

sub list {
    my ($self) = @_;

    if (! $self->{repo_list}) {
        my $repo_list = $self->gh->repos->list(user => $self->user);
        while (my $repo = $repo_list->next) {
            push @{ $self->{repo_list} }, $repo;
        }
    }

    return $self->{repo_list};
}
sub repos {
    my ($self) = @_;

    my $repos = $self->list;

    my $repo_count = 0;
    for my $repo (@$repos){
        $repo_count++;

        if ($self->limit) {
            last if $repo_count >= $self->limit;
        }

        $self->_trap->hook('stderr');

        print "Cloning $repo->{name}\n";

        my $stg = $self->stg . "/$repo->{name}";

        if (! $self->forks){
            if (! exists $repo->{parent}){
                Git::Repository->run(
                    clone => $repo->{clone_url} => $stg,
                    { quiet => 0 }
                );
            }
        }
        else {
             Git::Repository->run(
                clone => $repo->{clone_url} => $stg,
                { quiet => 0 }
            );
        }
        $self->_trap->unhook('stderr');
    }
}
sub issues {
    my ($self) = @_;

    mkdir $self->stg . "/issues" or die "can't create the 'issues' dir: $!";

    my $repos = $self->list;

    my $repo_count = 0;

    for my $repo (@$repos) {
        $repo_count++;

        if ($self->limit) {
            last if $repo_count >= $self->limit;
        }

        my $closed_issue_list = $self->gh->issues->list(
            user => $self->user,
            repo => $repo->{name},
            params => {
                state => 'closed'
            }
        );

        my $open_issue_list = $self->gh->issues->list(
            user => $self->user,
            repo => $repo->{name},
            params => {
                state => 'open'
            }
        );

        my $open_issues     = $open_issue_list->content;
        my $closed_issues   = $closed_issue_list->content;

        my $issue_dir = $self->stg . "/issues/$repo->{name}";

        my $dir_created = 0;

        for my $issue (@$open_issues, @$closed_issues) {
            if (! $dir_created) {
                mkdir $issue_dir            or die $!;
                mkdir "$issue_dir/open"     or die $!;
                mkdir "$issue_dir/closed"   or die $!;
                $dir_created = 1;
            }

            my $issue_path = $issue->{state} eq 'open'
                ? "$issue_dir/open/$issue->{id}"
                : "$issue_dir/closed/$issue->{id}";

            open my $fh, '>', $issue_path or die "can't create the issue file";

            print "Copied $repo->{name} issue #$issue->{number} to $issue_path\n";

            print $fh encode_json $issue;
        }
    }
}
sub finish {
    my ($self) = @_;
    if ($self->stg && -d $self->stg) {
        move $self->stg,
            $self->dir or die "can't rename the staging directory: $!";
    }
}
sub _trap {
    my ($self) = @_;
    if (! $self->{trap}) {
        $self->{trap} = Hook::Output::Tiny->new;
    }

    return $self->{trap};
}
sub DESTROY {
    my $self = shift;

    if ($self->dir && -d $self->dir) {
        rmtree $self->dir or die "can't remove the old backup directory: $!";
    }

    if ($self->stg && -d $self->stg) {
        move $self->stg,
            $self->dir or die "can't rename the staging directory: $!";
    }

    if ($self->dir && -d $self->dir && $self->_clean) {
        # we're in testing mode, clean everything up
        rmtree $self->dir
            or die "can't remove the test backup directory...$!";
    }
}

1;
__END__