File Coverage

blib/lib/Text/Mining/Parser/Base.pm

Criterion	Covered	Total	%
statement	3	3	100.0
branch			n/a
condition			n/a
subroutine	1	1	100.0
pod			n/a
total	4	4	100.0

package Text::Mining::Parser::Base;
use base qw(Text::Mining::Base);
use Class::Std;
use Class::Std::Utils;
use Module::Runtime qw(use_module);

use warnings;
use strict;
use Carp;

use version; our $VERSION = qv('0.0.8');

{
	my %document_of      : ATTR( get => 'document', set => 'document' );
	my %token_list_of    : ATTR( get => 'token_list', set => 'token_list' );
	my %algorithm_of     : ATTR( get => 'algorithm', set => 'algorithm' );
	my %section_ndx_of   : ATTR( default => 1, get => 'section_ndx', set => 'section_ndx' );
	my %paragraph_ndx_of : ATTR( default => 1, get => 'paragraph_ndx', set => 'paragraph_ndx' );
	my %line_ndx_of      : ATTR( default => 1, get => 'line_ndx', set => 'line_ndx' );

	sub version { return "Text::Mining::Parser::Base Version $VERSION"; }

	sub BUILD {
		my ($self, $ident, $arg_ref) = @_;

		my $algorithm = use_module('Text::Mining::Algorithm::' . $arg_ref->{algorithm}, 0.0.1)->new( $arg_ref );
		$self->set_algorithm( $algorithm );

		return;
	}

	sub parse_document() {
		my ($self, $arg_ref) = @_;

		# Check for new document, get document
		if (defined $arg_ref->{document}) { $self->set_document( $arg_ref->{document} ); }
		my $document  = $self->get_document();

		my $algorithm = $self->get_algorithm();

		# This design assumes text will fit in a scalar. Will probably need
		# a handle-based method using random access.

		# PD: Parse and process the entire text
		my $text = $self->_get_all_text();
		$algorithm->_by_text({ text => $text });

		# PD: Parse and process each document section
		my $section = $self->_get_next_section();
		while (defined $section) { $algorithm->_by_section({ section => $section }); $section = $self->_get_next_section(); }

		# PD: Parse and process each document paragraph
		my $paragraph = $self->_get_next_paragraph();
		while (defined $paragraph) { $algorithm->_by_paragraph({ paragraph => $paragraph }); $paragraph = $self->_get_next_paragraph(); }

		# PD: Parse and process each document line
		my $line = $self->_get_next_line();
		while (defined $line) { $algorithm->_by_line({ line => $line }); $line = $self->_get_next_line(); }

		# PD: Annotate the token list
		#$self->_annotate();

		return;
	}

	sub parse {
		my ($self, $arg_ref) = @_;

		use Text::Mining::Algorithm::AllTokens;

		my $text = $self->_get_file_text( $self->get_file_name() );
		my $algorithm = Text::Mining::Algorithm::AllTokens->new();
		my $tokens = $algorithm->harvest_tokens( $arg_ref );

		return $tokens;
	}

	sub stats {
		my ($self, $arg_ref) = @_;

		my $text = $self->_get_file_text( $self->get_file_name() );
		my @lines     = split(/\n/, $text);
		my @sentences = split(/\./, $text);
		my @tokens    = split(/\s+/, $text);

		return " Lines: " . scalar( @lines) . ";",
		       " Sentences: " . scalar( @sentences) . ";",
		       " Tokens: " . scalar( @tokens) . ";";
	}

	sub _get_all_text() {
		my ($self, $arg_ref) = @_;
		return;
	}

	sub _get_next_section() {
		my ($self, $arg_ref) = @_;
		return;
	}

	sub _get_next_paragraph() {
		my ($self, $arg_ref) = @_;
		return;
	}

	sub _get_next_line() {
		my ($self, $arg_ref) = @_;
		return;
	}

	sub _update_stats() {
		my ($self, $arg_ref) = @_;
		return;
	}

	sub _annotate() {
		my ($self, $arg_ref) = @_;
		my $algorithm = $self->get_algorithm();

		$self->get_document()->annotate({ type => 'parser', value => $self->version() });
		$self->get_document()->annotate({ type => 'algorithm', value => $algorithm->version() });
		return;
	}

}

1; # Magic true value required at end of module
__END__