File Coverage

blib/lib/MediaWiki/DumpFile/Compat.pm

Criterion	Covered	Total	%
statement	34	64	53.1
branch	0	4	0.0
condition			n/a
subroutine	12	22	54.5
pod			n/a
total	46	90	51.1

#!/usr/bin/env perl

#Parse::MediaWikiDump compatibility

package MediaWiki::DumpFile::Compat;

our $VERSION = '0.2.0';

package #go away indexer!
	Parse::MediaWikiDump;

use strict;
use warnings;

sub new {
	my ($class) = @_;
	return bless({}, $class);
}

sub pages {
	shift(@_);
	return Parse::MediaWikiDump::Pages->new(@_);
}

sub revisions {
	shift(@_);
	return Parse::MediaWikiDump::Revisions->new(@_);
}

sub links {
	shift(@_);
	return Parse::MediaWikiDump::Links->new(@_);
}

package #go away indexer!
	Parse::MediaWikiDump::Links;

use strict;
use warnings;

use MediaWiki::DumpFile::SQL;

sub new {
	my ($class, $source) = @_;
	my $self = {};
	my $sql;

	$Carp::CarpLevel++;
	$sql = MediaWiki::DumpFile::SQL->new($source);
	$Carp::CarpLevel--;

	if (! defined($sql)) {
		die "could not create SQL parser";
	}

	$self->{sql} = $sql;

	return bless($self, $class);
}

sub next {
	my ($self) = @_;
	my $next = $self->{sql}->next;

	unless(defined($next)) {
		return undef;
	}

	return Parse::MediaWikiDump::link->new($next);
}

package #go away indexer!
	Parse::MediaWikiDump::link;

use strict;
use warnings;

use Data::Dumper;

sub new {
	my ($class, $self) = @_;

	bless($self, $class);
}

sub from {
	return $_[0]->{pl_from};
}

sub namespace {
	return $_[0]->{pl_namespace};
}

sub to {
	return $_[0]->{pl_title};
}

package #go away indexer!
	Parse::MediaWikiDump::Revisions;

use strict;
use warnings;
use Data::Dumper;

use MediaWiki::DumpFile::Pages;

sub new {
	my ($class, @args) = @_;
	my $self = { queue => [] };
	my $mediawiki;

	$Carp::CarpLevel++;
	$mediawiki = MediaWiki::DumpFile::Pages->new(@args);
	$Carp::CarpLevel--;

	$self->{mediawiki} = $mediawiki;

	return bless($self, $class);
}

sub version {
	return $_[0]->{mediawiki}->version;
}

sub sitename {
	return $_[0]->{mediawiki}->sitename;
}

sub base {
	return $_[0]->{mediawiki}->base;
}

sub generator {
	return $_[0]->{mediawiki}->generator;
}

sub case {
	return $_[0]->{mediawiki}->case;
}

sub namespaces {
	my $cache = $_[0]->{cache}->{namespaces};

	if(defined($cache)) {
		return $cache;
	}

	my %namespaces = $_[0]->{mediawiki}->namespaces;
	my @temp;

	while(my ($key, $val) = each(%namespaces)) {
		push(@temp, [$key, $val]);
	}

	@temp = sort({$a->[0] <=> $b->[0]} @temp);

	$_[0]->{cache}->{namespaces} = \@temp;

	return \@temp;
}

sub namespaces_names {
	my ($self) = @_;
	my @result;

	return $self->{cache}->{namespaces_names} if defined $self->{cache}->{namespaces_names};

	foreach (@{ $_[0]->namespaces }) {
		push(@result, $_->[1]);
	}

	$self->{cache}->{namespaces_names} = \@result;

	return \@result;
}

sub current_byte {
	return $_[0]->{mediawiki}->current_byte;
}

sub size {
	return $_[0]->{mediawiki}->size;
}

sub get_category_anchor {
	my ($self) = @_;
	my $namespaces = $self->namespaces;
	my $cache = $self->{cache};
	my $ret = undef;

	if (defined($cache->{category_anchor})) {
		return $cache->{category_anchor};
	}

	foreach (@$namespaces) {
		my ($id, $name) = @$_;
		if ($id == 14) {
			$ret = $name;
		}
	}

	$self->{cache}->{category_anchor} = $ret;

	return $ret;
}

sub next {
	my $self = $_[0];
	my $queue = $_[0]->{queue};
	my $next = shift(@$queue);
	my @results;

	return $next if defined $next;

	$next = $self->{mediawiki}->next;

	return undef unless defined $next;

	foreach ($next->revision) {
		push(@$queue, Parse::MediaWikiDump::page->new($next, $self->namespaces, $self->get_category_anchor, $_));
	}

	return shift(@$queue);
}

package #go away indexer!
	Parse::MediaWikiDump::Pages;

use strict;
use warnings;

our @ISA = qw(Parse::MediaWikiDump::Revisions);

sub next {
	my $self = $_[0];
	my $next = $self->{mediawiki}->next;
	my $revision_count;

	return undef unless defined $next;

	$revision_count = scalar(@{[$next->revision]});
						#^^^^^ because scalar($next->revision) doesn't work

	if ($revision_count > 1) {
		die "only one revision per page is allowed\n";
	}

	return Parse::MediaWikiDump::page->new($next, $self->namespaces, $self->get_category_anchor);
}


package #go away indexer!
	Parse::MediaWikiDump::page;

use strict;
use warnings;

our %REGEX_CACHE_CATEGORIES;

sub new {
	my ($class, $page, $namespaces, $category_anchor, $revision) = @_;
	my $self = {page => $page, namespaces => $namespaces, category_anchor => $category_anchor};

	$self->{revision} = $revision;

	return bless($self, $class);
}

sub _revision {
	if (defined($_[0]->{revision})) { return $_[0]->{revision}};

	return $_[0]->{page}->revision;
}

sub text {
	my $text = $_[0]->_revision->text;
	return \$text;
}

sub title {
	return $_[0]->{page}->title;
}

sub id {
	return $_[0]->{page}->id;
}

sub revision_id {
	return $_[0]->_revision->id;
}

sub username {
	return $_[0]->_revision->contributor->username;
}

sub userid {
	return $_[0]->_revision->contributor->id;
}

sub userip {
	return $_[0]->_revision->contributor->ip;
}

sub timestamp {
	return $_[0]->_revision->timestamp;
}

sub minor {
	return $_[0]->_revision->minor;
}

sub namespace {
	my ($self) = @_;
	my $title = $self->title;
	my $namespace = '';

	if (defined($self->{cache}->{namespace})) {
		return $self->{cache}->{namespace};
	}

	if ($title =~ m/^([^:]+):(.*)/o) {
		foreach (@{ $self->{namespaces} } ) {
			my ($num, $name) = @$_;
			if ($1 eq $name) {
				$namespace = $1;
				last;
			}
		}
	}

	$self->{cache}->{namespace} = $namespace;

	return $namespace;
}

sub redirect {
	my ($self) = @_;
	my $text = $self->text;
	my $ret;

	return $self->{cache}->{redirect} if defined $self->{cache}->{redirect};

	if ($$text =~ m/^#redirect\s*:?\s*\[\[([^\]]*)\]\]/io) {
		$ret = $1;
	} else {
		$ret = undef;
	}

	$self->{cache}->{redirect} = $ret;

	return $ret;
}

sub categories {
	my ($self) = @_;
	my $anchor = $$self{category_anchor};
	my $text = $self->text;
	my @cats;
	my $ret;

	return $self->{cache}->{categories} if defined $self->{cache}->{categories};

	if (! defined($REGEX_CACHE_CATEGORIES{$anchor})) {
		$REGEX_CACHE_CATEGORIES{$anchor} = qr/\[\[$anchor:\s*([^\]]+)\]\]/i;
	}

	while($$text =~ /$REGEX_CACHE_CATEGORIES{$anchor}/g) {
		my $buf = $1;

		#deal with the pipe trick
		$buf =~ s/\|.*$//;
		push(@cats, $buf);
	}

	if (scalar(@cats) == 0) {
		$ret = undef;
	} else {
		$ret = \@cats;
	}

	return $ret;
}


1;

__END__