ALPM
view release on metacpan or search on metacpan
negative_is_error
unregister_all(self)
ALPM_Handle self
CODE:
RETVAL = alpm_unregister_all_syncdbs(self);
OUTPUT:
RETVAL
# Packages created with load_pkgfile must be freed by the caller.
# Hence we use ALPM_PackageFree. NULL pointers are converted
# into undef by the typemap.
ALPM_PackageFree
load_pkgfile(self, filename, full, siglevel)
ALPM_Handle self
const char *filename
int full
ALPM_SigLevel siglevel
CODE:
RETVAL = NULL;
alpm_pkg_load(self, filename, full, siglevel, &RETVAL);
* lib/ALPM.pm (transaction): Removed type parameter from
transaction method.
* ALPM.xs: Renamed ALPM::DB method set_server to add_url.
2010-05-29 Justin Davis <juster@cpan.org>
* RELEASE (0.08): Uploaded to CPAN.
* typemap (find_group): Fix a bug with group type conversion.
This caused ALPM::DB::find_group() to croak instead of (properly)
returning undef when given a group name that didn't exist.
Reported by Andre Schmidt. Thanks!
2010-05-24 Justin Davis <juster@cpan.org>
* ALPM.xs (ALPM::Package): Renamed compute_requiredby method to
requiredby.
2010-05-02 Justin Davis <juster@cpan.org>
Changes
Makefile.PL
MANIFEST
MANIFEST.SKIP
README
ppport.h
ALPM.xs
alpm_xs.h
cb.c
cb.h
typemap
types.c
types.h
t/00-ALPM.t
t/01-Conf.t
t/02-DB.t
t/03-Package.t
t/04-Misc.t
t/05-Callbacks.t
t/repos/build/simpletest/bar/.PKGINFO
t/repos/build/simpletest/bar/usr/foo/bar/bar
die q{You can't use both -i and -e} if $i && $e;
for my $pkg ($alpm->localdb->pkgs){
next if(@{$pkg->requiredby} > 0);
if($i || $e){
next if($pkg->reason ne ($i ? 'implicit' : 'explicit'));
}
push @dangles, $pkg->name;
}
print map { "$_\n" } sort @dangles;
unless(@ARGV){
print STDERR "usage: ownzors [file paths]\n";
exit 2;
}
for my $pkg ($alpm->localdb->pkgs) {
$who_owns{$_->{'name'}} = $pkg->name for(@{$pkg->files});
}
push @{$results{$who_owns{$_}}}, $_
for(map { s{\A/}{}; $_ } map { File::Spec->rel2abs($_) } @ARGV);
## Happy A! \o/
if($q){
print $_, "\n" for(sort keys %results);
exit 0;
}
for my $pkgname (sort keys %results){
print $pkgname, "\n", map { "\t/$_\n" } sort @{$results{$pkgname}};
}
lib/ALPM.pm view on Meta::CPAN
my($self, $name) = @_;
for my $db ($self->dbs){
return $db if($db->name eq $name);
}
return undef;
}
sub search
{
my($self, @qry) = @_;
return map { $_->search(@qry) } $self->dbs;
}
1;
lib/ALPM/Conf.pm view on Meta::CPAN
die qq{$fld can only be set in the [options] section\n}
unless($$sectref eq 'options');
$optsref->{$opt} = $val;
};
}
return %hooks;
}
sub _nullhooks
{
map { ($_ => \&_null) } @_
}
sub _getdb
{
my($dbs, $name) = @_;
# The order databases are added must be preserved as must the order of URLs.
for my $db (@$dbs){
return $db if($db->{'name'} eq $name);
}
lib/ALPM/Conf.pm view on Meta::CPAN
}
sub _setopt
{
my($alpm, $opt, $valstr) = @_;
no strict 'refs';
my $meth = *{"ALPM::set_$opt"}{'CODE'};
die "The ALPM::set_$opt method is missing" unless($meth);
my @val = ($opt =~ /s$/ ? map { split } $valstr : $valstr);
return $meth->($alpm, @val);
}
sub _setarch
{
my($opts) = @_;
if(!$opts->{'arch'} || $opts->{'arch'} eq 'auto'){
chomp ($opts->{'arch'} = `uname -m`);
}
}
lib/ALPM/Conf.pm view on Meta::CPAN
unless($dbpath){
$dbpath = "$root/var/lib/pacman";
$dbpath =~ tr{/}{/}s;
}
}
my $alpm = ALPM->new($root, $dbpath);
_setarch($opts);
while(my ($opt, $val) = each %$opts){
# The SetOption type in typemap croaks on error, no need to check.
_setopt($alpm, $opt, $val);
}
my $usesl = grep { /signatures/ } $alpm->caps;
for my $db (@$dbs){
my($r, $sl, $mirs) = @{$db}{'name', 'siglvl', 'mirrors'};
next if(!@$mirs);
_expurls($mirs, $opts->{'arch'}, $r);
$sl = 'default' if(!$usesl);
die "Invalid version number format: '$opt{'compat-version'}'\n";
}
die "Only Perl 5 is supported\n" if $r != 5;
die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000;
$opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s;
}
else {
$opt{'compat-version'} = 5;
}
my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
? ( $1 => {
($2 ? ( base => $2 ) : ()),
($3 ? ( todo => $3 ) : ()),
(index($4, 'v') >= 0 ? ( varargs => 1 ) : ()),
(index($4, 'p') >= 0 ? ( provided => 1 ) : ()),
(index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()),
} )
: die "invalid spec: $_" } qw(
AvFILLp|5.004050||p
AvFILL|||
}
$function = [$1, ''] if m{^DPPP_\(my_(\w+)\)};
$replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};
$replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};
$replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce};
$replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$};
if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) {
my @deps = map { s/\s+//g; $_ } split /,/, $3;
my $d;
for $d (map { s/\s+//g; $_ } split /,/, $1) {
push @{$depends{$d}}, @deps;
}
}
$need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};
}
for (values %depends) {
my %s;
$_ = [sort grep !$s{$_}++, @$_];
push @flags, 'hint' if exists $hints{$f};
push @flags, 'warning' if exists $warnings{$f};
my $flags = @flags ? ' ['.join(', ', @flags).']' : '';
print "$f$flags\n";
}
exit 0;
}
my @files;
my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc );
my $srcext = join '|', map { quotemeta $_ } @srcext;
if (@ARGV) {
my %seen;
for (@ARGV) {
if (-e) {
if (-f) {
push @files, $_ unless $seen{$_}++;
}
else { warn "'$_' is not a file.\n" }
}
}
else {
eval {
require File::Find;
File::Find::find(sub {
$File::Find::name =~ /($srcext)$/i
and push @files, $File::Find::name;
}, '.');
};
if ($@) {
@files = map { glob "*$_" } @srcext;
}
}
if (!@ARGV || $opt{filter}) {
my(@in, @out);
my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
for (@files) {
my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i;
push @{ $out ? \@out : \@in }, $_;
}
if (@ARGV && @out) {
warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out);
}
@files = @in;
}
return undef;
}
sub rec_depend
{
my($func, $seen) = @_;
return () unless exists $depends{$func};
$seen = {%{$seen||{}}};
return () if $seen->{$func}++;
my %s;
grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}};
}
sub parse_version
{
my $ver = shift;
if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) {
return ($1, $2, $3);
}
elsif ($ver !~ /^\d+\.[\d_]+$/) {
use Test::More;
use ALPM::Conf 't/test.conf';
ok $alpm;
sub checkpkgs
{
my $db = shift;
my $dbname = $db->name;
my %set = map { ($_ => 1) } @_;
for my $p ($db->pkgs){
my $n = $p->name;
unless(exists $set{$n}){
fail "unexpected $n package exists in $dbname";
return;
}
delete $set{$n};
}
if(keys %set){
fail "missing packages in $dbname: " . join q{ }, keys %set;
t/repos/package.pl view on Meta::CPAN
{
my($base) = @_;
remkdir("$base/tmp");
return "$base/tmp";
}
sub pkgfname
{
my($pi) = @_;
return sprintf '%s-%s-%s.pkg.tar.xz',
map { $_->[0] } @{$pi}{qw/pkgname pkgver arch/};
}
sub buildpkg
{
my($pi, $pd, $td) = @_;
my $parentd = dirname($td);
remkdir($td);
system 'cp' => ('-R', $pd, $parentd);
if($?){
t/repos/package.pl view on Meta::CPAN
unless(-f "$pd/.PKGINFO"){
print STDERR "$PROG: $pd/.PKGINFO is missing\n";
exit 1;
}
return undef unless(-d $td);
my $fname = pkgfname($pi);
return undef unless(-f "$td/$fname");
my($itime, $ptime) = map { my $s = stat $_; $s->mtime }
("$pd/.PKGINFO", "$td/$fname");
return undef if($itime > $ptime);
return "$td/$fname";
}
my $wd = getcwd();
my $bd = 'build';
my $td = mktmpdir($bd);
my $repos = readrepos($bd);
my @pkgfiles;
t/repos/repoadd.pl view on Meta::CPAN
}
close $of or die "close: $!";
$self;
}
sub addEntry
{
my($self, $pkg) = @_;
my $pi = $pkg->info;
my $name = join q{-}, map { $_->[0] } @{$pi}{qw/name version/};
my $dir = "$self->{'dir'}/$name";
if(-d $dir){
system 'rm' => '-r', "$dir";
if($?){
print STDERR "$PROG: failed to unlink dir: $dir\n";
exit 1;
}
}
mkdir $dir or die "mkdir: $!";
if((len = strlen(buf)) == 0) goto unknown;
return newSVpv(buf, len-1);
unknown:
return newSVpv("unknown", 0);
}
/* LIST CONVERSIONS */
AV *
list2av(alpm_list_t *L, scalarmap F)
{
AV *av;
av = newAV();
while(L){
av_push(av, F(L->data));
L = alpm_list_next(L);
}
return av;
}
alpm_list_t *
av2list(AV *A, listmap F)
{
alpm_list_t *L;
int i;
SV **sv;
L = NULL;
for(i = 0; i < av_len(A); i++){
sv = av_fetch(A, i, 0);
L = alpm_list_add(L, F(*sv));
}
#ifndef _ALPMXS_TYPES
#define _ALPMXS_TYPES
/* TYPEDEFS */
/* Used in typemap and xs/Options.xs. */
typedef int SetOption;
typedef int IntOption;
typedef char * StringOption;
typedef int negative_is_error;
typedef alpm_handle_t * ALPM_Handle;
typedef alpm_db_t * ALPM_DB;
typedef alpm_db_t * ALPM_LocalDB;
typedef alpm_db_t * ALPM_SyncDB;
typedef alpm_pkg_t * ALPM_Package;
typedef alpm_list_t * StringListFree;
typedef alpm_list_t * StringList;
typedef alpm_list_t * PackageListNoFree;
typedef alpm_list_t * DependList;
typedef alpm_list_t * ListAutoFree;
typedef alpm_filelist_t * ALPM_FileList;
/* these are for list converter functions */
typedef SV* (*scalarmap)(void*);
typedef void* (*listmap)(SV*);
/* CONVERTER FUNC PROTOS */
SV* c2p_str(void*);
const char* p2c_str(SV*);
SV* c2p_pkg(void*);
ALPM_Package p2c_pkg(SV*);
ALPM_DB p2c_db(SV*);
alpm_siglevel_t p2c_siglevel(SV*);
SV* c2p_pkgreason(alpm_pkgreason_t);
alpm_pkgreason_t p2c_pkgreason(SV*);
SV* c2p_pkgfrom(alpm_pkgfrom_t);
SV* c2p_pkgvalidation(alpm_pkgvalidation_t);
/* LIST CONVERTER FUNC PROTOS */
AV* list2av(alpm_list_t*, scalarmap);
alpm_list_t* av2list(AV*, listmap);
#define LIST2STACK(L, F)\
while(L){\
XPUSHs(sv_2mortal(F(L->data)));\
L = alpm_list_next(L);\
}
#define STACK2LIST(I, L, F)\
L = NULL;\
while(I < items){\
( run in 0.718 second using v1.01-cache-2.11-cpan-49f99fa48dc )