Pcore

 view release on metacpan or  search on metacpan

lib/Pcore/API/Docker/Hub.pm  view on Meta::CPAN

# CREATE REPO / AUTOMATED BUILD
sub create_repo ( $self, $repo_id, %args ) {
    %args = (
        private   => 0,
        desc      => $EMPTY,
        full_desc => $EMPTY,
        %args
    );

    my ( $namespace, $name ) = split m[/]sm, $repo_id;

    return $self->_req(
        'POST',
        '/repositories/',
        {   namespace        => $namespace,
            name             => $name,
            is_private       => $args{private},
            description      => $args{desc},
            full_description => $args{full_desc},
        }

lib/Pcore/API/Docker/Hub.pm  view on Meta::CPAN

# TODO not work
sub create_autobuild ( $self, $repo_id, $git_repo_id, $desc, %args ) {
    %args = (
        desc       => undef,
        private    => 0,
        active     => 1,
        build_tags => undef,
        %args,
    );

    my ( $namespace, $name ) = split m[/]sm, $repo_id;

    my $build_tags;

    # prepare build tags
    if ( !$args{build_tags} ) {
        $build_tags = [
            {   name                => '{sourceref}',                                                # docker build tag name
                source_type         => $DOCKERHUB_SOURCE_TYPE_NAME->{$DOCKERHUB_SOURCE_TYPE_TAG},    # Branch, Tag
                source_name         => '/.*/',                                                       # barnch / tag name in the source repository
                dockerfile_location => '/',

lib/Pcore/API/Docker/Hub.pm  view on Meta::CPAN

            $data->{ $tag->{id} } = $tag;
        }

        $res->{data} = $data;
    }

    return $res;
}

sub create_autobuild_tag ( $self, $repo_id, $tag_name, $source_name, $source_type, $dockerfile_location ) {
    my ( $namespace, $name ) = split m[/]sm, $repo_id;

    return $self->_req(
        'POST',
        "/repositories/$repo_id/autobuild/tags/",
        {   name                => $tag_name,
            dockerfile_location => $dockerfile_location // '/',
            source_name         => $source_name,
            source_type         => $DOCKERHUB_SOURCE_TYPE_NAME->{ lc $source_type },
            isNew               => \1,
            repoName            => $name,

lib/Pcore/API/Git/Upstream.pm  view on Meta::CPAN

                }
            }

            ( $args->{repo_namespace}, $args->{repo_name} ) = ( $url->{path} =~ m[/([[:alnum:]_-]+)/([[:alnum:]_-]+)]smi );
        }

        $args->{repo_id} = "$args->{repo_namespace}/$args->{repo_name}";
    }
    else {
        if ( $args->{repo_id} ) {
            ( $args->{repo_namespace}, $args->{repo_name} ) = split m[/]sm, $args->{repo_id};
        }
        else {
            $args->{repo_id} = "$args->{repo_namespace}/$args->{repo_name}";
        }
    }

    if ( $args->{host} ) {
        $args->{hosting} ||= $GIT_UPSTREAM_HOST_NAME->{ $args->{host} } if exists $GIT_UPSTREAM_HOST_NAME->{ $args->{host} };
    }
    elsif ( $args->{hosting} ) {

lib/Pcore/API/GitHub.pm  view on Meta::CPAN

        homepage      => undef,
        has_downloads => 1,
        @args
    );

    $args{private}       = delete $args{is_private} ? \1 : \0;
    $args{has_issues}    = $args{has_issues}        ? \1 : \0;
    $args{has_wiki}      = $args{has_wiki}          ? \1 : \0;
    $args{has_downloads} = $args{has_downloads}     ? \1 : \0;

    ( my $repo_namespace, $args{name} ) = split m[/]sm, $repo_id;

    my $endpoint;

    if ( $repo_namespace eq $self->{username} ) {
        $endpoint = '/user/repos';
    }
    else {
        $endpoint = "/orgs/$repo_namespace/repos";
    }

lib/Pcore/Util/File.pm  view on Meta::CPAN

    my @extracted;

    for my $file ( $tar->get_files ) {
        next if !defined $file->{filename};

        my $path = P->path( '/' . $file->full_path );

        if ( $args{strip_component} ) {
            if ( !$strip_component ) {
                my @labels = split m[/]sm, $path;

                die q[Can't strip component, path is too short] if @labels < $args{strip_component};

                $strip_component = P->path( '/' . join( '/', splice @labels, 0, $args{strip_component} + 1 ) );
            }

            die qq[Can't strip component "$strip_component" from path "$path"] if $path !~ s[\A$strip_component][]sm;
        }

        my $target_path = P->path("$target/$path");

lib/Pcore/Util/MIME.pm  view on Meta::CPAN

our $DATA;

sub _load_data {
    if ( !defined $DATA ) {
        $DATA = $ENV->{share}->read_cfg('/Pcore/data/mime.yaml');    ## no critic qw[Variables::RequireLocalizedPunctuationVars]

        state $get_tags = sub ($data) {
            my $type = shift $data->@*;

            push $data->@*, split m[/]sm, $type, 2;

            my $tags = { map { $_ => 1 } $data->@* };

            # text types can be compressed
            $tags->{compress} = 1 if exists $tags->{text};

            return $type, $tags;
        };

        for my $key (qw[custom_suffix filename suffix]) {

lib/Pcore/Util/Src/Filter/html.pm  view on Meta::CPAN

    my $res = $self->filter_prettier( parser => 'html' );

    return $res;
}

sub compress ($self) {
    return $SRC_OK if $self->has_kolon;

    # compress js
    my @script = split m[(<script[^>]*>)(.*?)(</script[^>]*>)]smi, $self->{data};

    for my $i ( 0 .. $#script ) {
        if ( $script[$i] =~ m/\A<script/sm && $script[ $i + 1 ] ) {
            my $res = Pcore::Util::Src::Filter::js->compress( \$script[ $i + 1 ] );

            return $res if !$res;
        }
    }

    $self->{data} = join $EMPTY, @script;

    # compress css
    my @css = split m[(<style[^>]*>)(.*?)(</style[^>]*>)]smi, $self->{data};

    for my $i ( 0 .. $#css ) {
        if ( $css[$i] =~ m/\A<style/sm && $css[ $i + 1 ] ) {
            my $res = Pcore::Util::Src::Filter::css->compress( \$css[ $i + 1 ] );

            return $res if !$res;
        }
    }

    $self->{data} = join $EMPTY, @css;