view release on metacpan or  search on metacpan

lib/Alien/Build/Plugin/Download/GitHub.pm  view on Meta::CPAN

  }

  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
        {