File Coverage

blib/lib/Alien/Build/Plugin/Download/GitHub.pm

Criterion	Covered	Total	%
statement	87	113	76.9
branch	33	56	58.9
condition	10	21	47.6
subroutine	15	15	100.0
pod	1	1	100.0
total	146	206	70.8

package Alien::Build::Plugin::Download::GitHub;

use strict;
use warnings;
use 5.008001;
use Carp qw( croak );
use Path::Tiny qw( path );
use JSON::PP qw( decode_json );
use URI;
use Alien::Build::Plugin;
use Alien::Build::Plugin::Download::Negotiate;
use Alien::Build::Plugin::Extract::Negotiate;

# ABSTRACT: Alien::Build plugin to download from GitHub
our $VERSION = '0.10'; # VERSION


has github_user => sub { croak("github_user is required") };
has github_repo => sub { croak("github_repo is required") };
has include_assets => 0;
has version => qr/^v?(.*)$/;
has prefer => 0;
has tags_only => 0;


has asset => 0;
has asset_name => qr/\.tar\.gz$/;
has asset_format => 'tar.gz';
has asset_convert_version => 0;

my $once = 1;

sub init
{
  my($self, $meta) = @_;

  croak("Don't set set a start_url with the Download::GitHub plugin") if defined $meta->prop->{start_url};
  croak("cannot use both asset and tag_only") if $self->asset && $self->tags_only;

  if($self->asset)
  {
    $meta->add_requires('configure' => 'Alien::Build::Plugin::Download::GitHub' => '0.09' );
  }
  else
  {
    $meta->add_requires('configure' => 'Alien::Build::Plugin::Download::GitHub' => 0 );
  }

  my $endpoint = $self->tags_only ? 'tags' : 'releases' ;
  $meta->prop->{start_url} ||= "https://api.github.com/repos/@{[ $self->github_user ]}/@{[ $self->github_repo ]}/$endpoint";

  $meta->apply_plugin('Download',
    prefer  => $self->prefer,
    version => $self->version,
  );

  if($self->asset_format ne 'none')
  {
    if($self->asset && $self->asset_format)
    {
      $meta->apply_plugin('Extract',
        format  => $self->asset_format,
      )
    }
    else
    {
      $meta->apply_plugin('Extract',
        format  => 'tar.gz',
      );
    }
  }

  my %gh_fetch_options;
  my $secret;

  foreach my $name (qw( ALIEN_BUILD_GITHUB_TOKEN GITHUB_TOKEN GITHUB_PAT ))
  {
    if(defined $ENV{$name})
    {
      $secret = $ENV{$name};
      push @{ $gh_fetch_options{http_headers} }, Authorization => "token $secret";
      Alien::Build->log("using the GitHub Personal Access Token in $name") if $once;
      $once = 0;
      last;
    }
  }

  $meta->around_hook(
    fetch => sub {
      my $orig = shift;
      my($build, $url, @the_rest) = @_;

      # only do special stuff when talking to GitHub API.  In particular, this
      # avoids leaking the PAT (if specified) to other servers.
      return $orig->($build, $url, @the_rest)
        unless do {
          my $uri = URI->new($url || $build->meta_prop->{start_url});
          $uri->host eq 'api.github.com' && $uri->scheme eq 'https';
        };

      # Temporarily patch the log method so that we don't log the PAT
      my $log = \&Alien::Build::log;
      no warnings 'redefine';
      local *Alien::Build::log = sub {
        if(defined $secret)
        {
          $_[1] =~ s/\Q$secret\E/ '#' x length($secret) /eg;
        }
        goto &$log;
      };
      use warnings;

      my $res = $orig->($build, $url, @the_rest, %gh_fetch_options);
      if($res->{type} eq 'file' && $res->{filename} =~ qr{^(?:releases|tags)$})
      {
        my $rel;
        if($res->{content})
        {
          $rel = decode_json $res->{content};
        }
        elsif($res->{path})
        {
          $rel = decode_json path($res->{path})->slurp_raw;
        }
        else
        {
          croak("malformed response object: no content or path");
        }
        my $version_key = $res->{filename} eq 'releases' ? 'tag_name' : 'name';

        if($ENV{ALIEN_BUILD_PLUGIN_DOWNLOAD_GITHUB_DEBUG})
        {
          require YAML;
          my $url = $url || $meta->prop->{start_url};
          $url = URI->new($url);
          $build->log(YAML::Dump({
            url => $url->path,
            res => $rel,
          }));
        }

        my $res2;

        if($self->asset)
        {
          $res2 = {
            type => 'list',
            list => [],
          };

          foreach my $release (@$rel)
          {
            foreach my $asset (@{ $release->{assets} })
            {
              if($asset->{name} =~ $self->asset_name)
              {
                push @{ $res2->{list} }, {
                  filename => $asset->{name},
                  url      => $asset->{browser_download_url},
                  version  => $self->asset_convert_version ? $self->asset_convert_version->($release->{name}) : $release->{name},
                };
              }
            }
          }
        }
        else
        {
          $res2 = {
            type     => 'list',
            list     => [
              map {
                my $release = $_;
                my($version) = $release->{$version_key} =~ $self->version;
                my @results = ({
                  filename => $release->{$version_key},
                  url      => $release->{tarball_url},
                  defined $version ? (version  => $version) : (),
                });

                if (my $include = $self->include_assets) {
                  my $filter = ref($include) eq 'Regexp' ? 1 : 0;
                  for my $asset(@{$release->{assets} || []}) {
                    push @results, {
                      asset_url => $asset->{url},
                      filename  => $asset->{name},
                      url       => $asset->{browser_download_url},
                      defined $version ? (version  => $version) : (),
                    } if (0 == $filter or $asset->{name} =~ $include);
                  }
                }
                @results;
              } @$rel
            ],
          };
        }

        if($ENV{ALIEN_BUILD_PLUGIN_DOWNLOAD_GITHUB_DEBUG})
        {
          require YAML;
          $build->log(YAML::Dump({
            res2 => $res2,
          }));
        }

        $res2->{protocol} = $res->{protocol} if exists $res->{protocol};
        return $res2;
      }
      else
      {
        return $res;
      }
    },
  );

  unless($self->prefer)
  {
    $meta->default_hook(
      prefer => sub {
        my($build, $res) = @_;
        $res;
      },
    );
  }

}

1;

__END__