File Coverage

blib/lib/Github/Backup.pm

Criterion	Covered	Total	%
statement	59	85	69.4
branch	17	40	42.5
condition	10	12	83.3
subroutine	14	16	87.5
pod	2	3	66.6
total	102	156	65.3

package Github::Backup;

use strict;
use warnings;

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

use namespace::clean;

our $VERSION = '1.02';

# 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',
);

# 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 ($self->api_user, $self->token, $self->dir){
        if (! $_){
            croak "When instantiating an object, the 'api_user', 'token' and " .
                  "'dir' parameters are mandatory...\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
    );

    $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 repos {
    my ($self) = @_;

    my $repo_list = $self->gh->repos->list(user => $self->user);

    my @repos;

    while (my $repo = $repo_list->next){
        push @repos, $repo;
    }

    for my $repo (@repos){

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

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

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

    my $repo_list = $self->gh->repos->list(user => $self->user);

    while (my $repo = $repo_list->next){
        my $issue_list = $self->gh->issues->list(
            user => $self->user,
            repo => $repo->{name}
        );

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


        my $dir_created = 0;

        while (my $issue = $issue_list->next){
            if (! $dir_created) {
                mkdir $issue_dir or die $!;
                $dir_created = 1;
            }
            open my $fh, '>', "$issue_dir/$issue->{id}"
                or die "can't create the issue file";

            print $fh encode_json $issue;
        }
    }
}
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__