App-PMUtils

 view release on metacpan or  search on metacpan

lib/App/PMUtils.pm  view on Meta::CPAN

            push @$res, @$mods > 1 ? {module=>$mod, path=>$_} : $_;
        }
    }

    if ($found) {
        [200, "OK", $res];
    } else {
        if ($args{dir}) {
            [200, "OK (not found)", "."];
        } else {
            [404, "No such module"];
        }
    }
}

$SPEC{pmdir} = do {
    my $meta = { %{ $SPEC{pmpath} } }; # shallow copy
    $meta->{summary} = "Get directory of locally installed Perl module/prefix";
    $meta->{description} = <<'_';

This is basically a shortcut for:

script/pmbin  view on Meta::CPAN

            push @$res, $_;
        }
        close $fh;
    }

    if ($has_ok && $has_nok) {
        [207, "Some OK", $res];
    } elsif ($has_ok) {
        [200, "All OK", $res];
    } elsif ($has_nok) {
        [404, "Can't find .packlist for module(s)"];
    } else {
        [200, "No items"];
    }
}

Perinci::CmdLine::Any->new(
    url => '/main/pmbin',
    read_config => 0,
    read_env => 0,
)->run;

script/pmchkver  view on Meta::CPAN

            unless ($apires->{success}) {
                $rec->{note} = "Failed API request (1): $apires->{status} - $apires->{reason}";
                last;
            }
            eval { $apires = JSON::MaybeXS::decode_json($apires->{content}) };
            if ($@) {
                $rec->{note} = "Invalid API response: not valid JSON: $@";
                last;
            }
            if ($apires->{message}) {
                if ($apires->{code} == 404) {
                    $rec->{on_cpan} = 0;
                    last;
                } else {
                    $rec->{note} = "Failed API request (2): $apires->{code} - $apires->{message}";
                    last;
                }
            }
            $rec->{on_cpan} = 1;
            $rec->{cpan_version} = $apires->{version};
        }

script/pmhtml  view on Meta::CPAN

sub pmhtml {
    require Browser::Open;
    require File::Temp;
    require File::Util::Tempdir;
    require Module::Path::More;

    my %args = @_;
    my $mod = $args{module};
    my $mpath = Module::Path::More::module_path(
        module => $mod, find_pmc=>0, find_pod=>$args{pod}, find_prefix=>0);
    return [404, "Can't find module $mod"] unless defined $mpath;

    my $tmpdir = File::Util::Tempdir::get_tempdir();
    my $cachedir = File::Temp::tempdir(CLEANUP => 1);
    my $name = $mod; $name =~ s/:+/_/g;
    my ($infh, $infile) = File::Temp::tempfile(
        "$name.XXXXXXXX", DIR=>$tmpdir, SUFFIX=>".pod");
    my $outfile = "$infile.html";
    system(
        "pod2html",
        "--infile", $mpath,

script/pmlatest  view on Meta::CPAN

            unless ($apires->{success}) {
                $rec->{note} = "Failed API request (1): $apires->{status} - $apires->{reason}";
                last;
            }
            eval { $apires = JSON::MaybeXS::decode_json($apires->{content}) };
            if ($@) {
                $rec->{note} = "Invalid API response: not valid JSON: $@";
                last;
            }
            if ($apires->{message}) {
                if ($apires->{code} == 404) {
                    $rec->{on_cpan} = 0;
                    last;
                } else {
                    $rec->{note} = "Failed API request (2): $apires->{code} - $apires->{message}";
                    last;
                }
            }
            $rec->{on_cpan} = 1;
            $rec->{cpan_version} = $apires->{version};
        }

script/pmless  view on Meta::CPAN

    my @mpaths;
    for my $mod (@$mods) {
        my $mpath = Module::Path::More::module_path(
            module => $mod, find_pmc=>0, find_pod=>$args{pod}, find_prefix=>0);
        if (defined $mpath) {
            push @mpaths, $mpath;
        } else {
            warn "pmless: Can't find path for module '$mod'\n";
        }
    }
    return [404, "Can't find path(s) for module(s)"] unless @mpaths;
    system "less", @mpaths;
    [200, "OK"];
}

Perinci::CmdLine::Any->new(
    url => '/main/pmless',
    read_config => 0,
    read_env => 0,
)->run;

script/pmminversion  view on Meta::CPAN

            $rec->{minimum_explicit_version} = $pmv->minimum_explicit_version;
        }
        if ($args{with_minimum_syntax_version}) {
            $rec->{minimum_syntax_version} = $pmv->minimum_syntax_version;
        }

        push @$res, $rec;
    }

    if (!$found) {
        [404, "No such module(s): " . join(", ", @$mods)];
    } else {
        [200, "OK", $res, {
            'table.fields' => [qw/module minimum_version minimum_explicit_version minimum_syntax_version/],
        }];
    }
}

Perinci::CmdLine::Any->new(
    url => '/main/pmminversion',
    read_config => 0,

script/pmversion  view on Meta::CPAN

        }

        if (defined $v) {
            push @$res, (@$mods > 1 ? "$mod $v" : $v);
        } else {
            push @$res, "Module $mod does not define \$VERSION";
        }
    }

    if (!$found) {
        [404, "No such module(s): " . join(", ", @$mods)];
    } else {
        [200, "OK", $res];
    }
}

Perinci::CmdLine::Any->new(
    url => '/main/pmversion',
    read_config => 0,
    read_env => 0,
)->run;

script/pmxs  view on Meta::CPAN

        $fres = uc($fres // '?');
        push @$res, @$mods > 1 ? {
            module=>$mod,
            xs=>$fres,
        } : $fres;
    }

    if ($found) {
        [200, "OK", $res];
    } else {
        [404, "No such module"];
    }
}

Perinci::CmdLine::Any->new(
    url => '/main/pmxs',
    read_config => 0,
    read_env => 0,
)->run;

# ABSTRACT: Check whether an installed Perl module is XS/pure-perl

script/podpath  view on Meta::CPAN

        my $mpath = Module::Path::More::module_path(
            module=>$pod, find_pmc=>0, find_pm=>0, find_pod=>1, find_prefix=>0,
            abs=>$args{abs}, all=>$args{all});
        $found++ if $mpath;
        push @$res, @$pods > 1 ? {pod=>$pod, path=>$mpath} : $mpath;
    }

    if ($found) {
        [200, "OK", $res];
    } else {
        [404, "No such POD"];
    }
}

Perinci::CmdLine::Any->new(
    url => '/main/podpath',
    read_config => 0,
    read_env => 0,
)->run;

# ABSTRACT: Get path to locally installed POD