X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FText%2FTradition%2FCollation%2FReading.pm;h=108548bd7c7a7a17c1da27d74aae39168f5844a9;hb=56772e8c48876c670c0cdb26451f4c59401795ef;hp=d2d1fb7684fa33d6cc374dffc9797babe895000f;hpb=fae52efdaeb4b67f58e47ec8ebe110537f2535ea;p=scpubgit%2Fstemmatology.git

diff --git a/lib/Text/Tradition/Collation/Reading.pm b/lib/Text/Tradition/Collation/Reading.pm
index d2d1fb7..108548b 100644
--- a/lib/Text/Tradition/Collation/Reading.pm
+++ b/lib/Text/Tradition/Collation/Reading.pm
@@ -1,12 +1,26 @@
 package Text::Tradition::Collation::Reading;
 
 use Moose;
+use Moose::Util::TypeConstraints;
+use JSON qw/ from_json /;
+use Module::Load;
+use Text::Tradition::Error;
+use XML::Easy::Syntax qw( $xml10_name_rx $xml10_namestartchar_rx );
+use YAML::XS;
 use overload '""' => \&_stringify, 'fallback' => 1;
 
+subtype 'ReadingID',
+	as 'Str',
+	where { $_ =~ /\A$xml10_name_rx\z/ },
+	message { 'Reading ID must be a valid XML attribute string' };
+	
+no Moose::Util::TypeConstraints;
+
 =head1 NAME
 
-Text::Tradition::Collation::Reading - represents a reading (usually a word) in a collation.
-    
+Text::Tradition::Collation::Reading - represents a reading (usually a word)
+in a collation.
+
 =head1 DESCRIPTION
 
 Text::Tradition is a library for representation and analysis of collated
@@ -19,12 +33,13 @@ a particular sequence
 
 =head2 new
 
-Creates a new reading in the given collation with the given attributes. 
+Creates a new reading in the given collation with the given attributes.
 Options include:
 
 =over 4
 
-=item collation - The Text::Tradition::Collation object to which this reading belongs.  Required.
+=item collation - The Text::Tradition::Collation object to which this
+reading belongs.  Required.
 
 =item id - A unique identifier for this reading. Required.
 
@@ -36,9 +51,11 @@ Options include:
 
 =item is_lacuna - The 'reading' represents a known gap in the text.
 
-=item is_ph - A temporary placeholder for apparatus parsing purposes.  Do not use unless you know what you are doing.
+=item is_ph - A temporary placeholder for apparatus parsing purposes.  Do
+not use unless you know what you are doing.
 
-=item rank - The sequence number of the reading. This should probably not be set manually.
+=item rank - The sequence number of the reading. This should probably not
+be set manually.
 
 =back
 
@@ -71,7 +88,7 @@ has 'collation' => (
 
 has 'id' => (
 	is => 'ro',
-	isa => 'Str',
+	isa => 'ReadingID',
 	required => 1,
 	);
 
@@ -85,7 +102,7 @@ has 'text' => (
 has 'language' => (
 	is => 'ro',
 	isa => 'Str',
-	default => 'Default',
+	predicate => 'has_language',
 	);
 	
 has 'is_start' => (
@@ -127,27 +144,36 @@ has 'rank' => (
     
 ## For morphological analysis
 
-has 'normal_form' => (
+has 'grammar_invalid' => (
 	is => 'rw',
-	isa => 'Str',
-	predicate => 'has_normal_form',
+	isa => 'Bool',
+	default => undef,
+	);
+	
+has 'is_nonsense' => (
+	is => 'rw',
+	isa => 'Bool',
+	default => undef,
 	);
 
-has 'lemma' => (
+has 'normal_form' => (
 	is => 'rw',
 	isa => 'Str',
-	predicate => 'has_lemma',
+	predicate => 'has_normal_form',
 	);
 
-has 'morphology' => (
+# Holds the lexemes for the reading.
+has 'reading_lexemes' => (
 	traits => ['Array'],
-	isa => 'ArrayRef[HashRef[ArrayRef[Text::Tradition::Collation::Reading::Morphology]]]',
+	isa => 'ArrayRef[Text::Tradition::Collation::Reading::Lexeme]',
 	handles => {
+		lexeme => 'get',
 		lexemes => 'elements',
-		has_morphology => 'count',
-		_clear_morph => 'clear',
-		_add_morph => 'push',
+		has_lexemes => 'count',
+		clear_lexemes => 'clear',
+		add_lexeme => 'push',
 		},
+	default => sub { [] },
 	);
 	
 ## For prefix/suffix readings
@@ -180,19 +206,36 @@ around BUILDARGS => sub {
 	if( exists $args->{'is_lacuna'} && !exists $args->{'text'} ) {
 		$args->{'text'} = '#LACUNA#';
 	} elsif( exists $args->{'is_start'} ) {
-		$args->{'id'} = '#START#';  # Change the ID to ensure we have only one
+		$args->{'id'} = '__START__';  # Change the ID to ensure we have only one
 		$args->{'text'} = '#START#';
 		$args->{'rank'} = 0;
 	} elsif( exists $args->{'is_end'} ) {
-		$args->{'id'} = '#END#';	# Change the ID to ensure we have only one
+		$args->{'id'} = '__END__';	# Change the ID to ensure we have only one
 		$args->{'text'} = '#END#';
 	} elsif( exists $args->{'is_ph'} ) {
 		$args->{'text'} = $args->{'id'};
 	}
 	
+	# Backwards compatibility for non-XMLname IDs
+	my $rid = $args->{'id'};
+	$rid =~ s/\#/__/g;
+	$rid =~ s/[\/,]/./g;
+    if( $rid !~ /^$xml10_namestartchar_rx/ ) {
+    	$rid = 'r'.$rid;
+    }
+	$args->{'id'} = $rid;
+	
 	$class->$orig( $args );
 };
 
+# Look for a lexeme-string argument in the build args.
+sub BUILD {
+	my( $self, $args ) = @_;
+	if( exists $args->{'lexemes'} ) {
+		$self->_deserialize_lexemes( $args->{'lexemes'} );
+	}
+}
+
 =head2 is_meta
 
 A meta attribute (ha ha), which should be true if any of our 'special'
@@ -206,6 +249,17 @@ sub is_meta {
 	return $self->is_start || $self->is_end || $self->is_lacuna || $self->is_ph;	
 }
 
+=head2 is_nonrel
+
+Similar to is_meta, but returns false for the start and end readings.
+
+=cut
+
+sub is_nonrel {
+	my $self = shift;
+	return $self->is_lacuna || $self->is_ph;
+}
+
 =head1 Convenience methods
 
 =head2 related_readings
@@ -274,77 +328,76 @@ sub _stringify {
 
 =head1 MORPHOLOGY
 
-A few methods to try to tack on morphological information.
+Methods for the morphological information (if any) attached to readings.
+A reading may be made up of multiple lexemes; the concatenated lexeme
+strings ought to match the reading's normalized form.
+ 
+See L<Text::Tradition::Collation::Reading::Lexeme> for more information
+on Lexeme objects and their attributes.
+
+=head2 has_lexemes
+
+Returns a true value if the reading has any attached lexemes.
+
+=head2 lexemes
+
+Returns the Lexeme objects (if any) attached to the reading.
+
+=head2 clear_lexemes
+
+Wipes any associated Lexeme objects out of the reading.
+
+=head2 add_lexeme( $lexobj )
+
+Adds the Lexeme in $lexobj to the list of lexemes.
 
-=head2 is_disambiguated
+=head2 lemmatize
 
-Returns true if there is only one tag per lexeme in this reading.
+If the language of the reading is set, this method will use the appropriate
+Language model to determine the lexemes that belong to this reading.  See
+L<Text::Tradition::lemmatize> if you wish to lemmatize an entire tradition.
 
 =cut
 
-sub use_lexemes {
-	my( $self, @lexemes ) = @_;
-	# The lexemes need to be the same as $self->text.
-	my $cmpstr = $self->has_normal_form ? lc( $self->normal_form ) : lc( $self->text );
-	$cmpstr =~ s/[\s-]+//g;
-	my $lexstr = lc( join( '', @lexemes ) );
-	$lexstr =~ s/[\s-]+//g;
-	unless( $lexstr eq $cmpstr ) {
-		warn "Cannot split " . $self->text . " into " . join( '.', @lexemes );
+sub lemmatize {
+	my $self = shift;
+	unless( $self->has_language ) {
+		warn "Please set a language to lemmatize a tradition";
 		return;
 	}
-	$self->_clear_morph;
-	map { $self->_add_morph( { $_ => [] } ) } @lexemes;
-}
+	my $mod = "Text::Tradition::Language::" . $self->language;
+	load( $mod );
+	$mod->can( 'reading_lookup' )->( $self );
 
-sub add_morphological_tag {
-	my( $self, $lexeme, $opts ) = @_;
-	my $struct;
-	unless( $opts ) {
-		# No lexeme was passed; use reading text.
-		$opts = $lexeme;
-		$lexeme = $self->text;
-		$self->use_lexemes( $lexeme );
-	}
-	# Get the correct container
-	( $struct ) = grep { exists $_->{$lexeme} } $self->lexemes;
-	unless( $struct ) {
-		warn "No lexeme $lexeme exists in this reading";
-		return;
-	}
-	# Now make the morph object and add it to this lexeme.
-	my $morph_obj = Text::Tradition::Collation::Reading::Morphology->new( $opts );
-	# TODO Check for existence
-	push( @{$struct->{$lexeme}}, $morph_obj );
 }
 
-sub disambiguate {
-	my( $self, $lexeme, $index ) = @_;
-	my $struct;
-	unless( $index ) {
-		# No lexeme was passed; use reading text.
-		$index = $lexeme;
-		$lexeme = $self->text;
-	}
-	# Get the correct container
-	( $struct ) = grep { exists $_->{$lexeme} } $self->lexemes;
-	unless( $struct ) {
-		warn "No lexeme $lexeme exists in this reading";
-		return;
-	}
-	# Keep the object at the selected index
-	my $selected = $struct->{$lexeme}->[$index];
-	$struct->{$lexeme} = [ $selected ];
+# For graph serialization. Return a JSON representation of the associated
+# reading lexemes.
+sub _serialize_lexemes {
+	my $self = shift;
+	my $json = JSON->new->allow_blessed(1)->convert_blessed(1);
+	return $json->encode( [ $self->lexemes ] );
 }
 
-sub is_disambiguated {
-	my $self = shift;
-	return undef unless $self->has_morphology;
-	foreach my $lexeme ( $self->lexemes ) {
-		my( $key ) = keys %$lexeme; # will be only one
-		return undef unless @{$lexeme->{$key}} == 1;
+# Given a JSON representation of the lexemes, instantiate them and add
+# them to the reading.
+sub _deserialize_lexemes {
+	my( $self, $json ) = @_;
+	my $data = from_json( $json );
+	return unless @$data;
+	
+	# Need to have the lexeme module in order to have lexemes.
+	eval { use Text::Tradition::Collation::Reading::Lexeme; };
+	throw( $@ ) if $@;
+	
+	# Good to go - add the lexemes.
+	my @lexemes;
+	foreach my $lexhash ( @$data ) {
+		push( @lexemes, Text::Tradition::Collation::Reading::Lexeme->new(
+			'JSON' => $lexhash ) );
 	}
-	return 1;
+	$self->clear_lexemes;
+	$self->add_lexeme( @lexemes );
 }
 
 ## Utility methods
@@ -354,92 +407,14 @@ sub TO_JSON {
 	return $self->text;
 }
 
-## TODO will need a throw() here
-
-no Moose;
-__PACKAGE__->meta->make_immutable;
-
-###################################################
-### Morphology objects, to be attached to readings
-###################################################
-
-package Text::Tradition::Collation::Reading::Morphology;
-
-use Moose;
-
-has 'lemma' => (
-	is => 'ro',
-	isa => 'Str',
-	required => 1,
-	);
-	
-has 'code' => (
-	is => 'ro',
-	isa => 'Str',
-	required => 1,
-	);
-	
-has 'language' => (
-	is => 'ro',
-	isa => 'Str',
-	required => 1,
-	);
-	
-## Transmute codes into comparison arrays for our various languages.
-
-around BUILDARGS => sub {
-	my $orig = shift;
-	my $class = shift;
-	my $args;
-	if( @_ == 1 && ref( $_[0] ) ) {
-		$args = shift;
-	} else {
-		$args = { @_ };
-	}
-	if( exists( $args->{'serial'} ) ) {
-		my( $lemma, $code ) = split( /!!/, delete $args->{'serial'} );
-		$args->{'lemma'} = $lemma;
-		$args->{'code'} = $code;
-	}
-	$class->$orig( $args );
-};
-
-sub serialization {
-	my $self = shift;
-	return join( '!!', $self->lemma, $self->code );
-};
-
-sub comparison_array {
-	my $self = shift;
-	if( $self->language eq 'French' ) {
-		my @array;
-		my @bits = split( /\+/, $self->code );
-		# First push the non k/v parts.
-		while( @bits && $bits[0] !~ /=/ ) {
-			push( @array, shift @bits );
-		}
-		while( @array < 2 ) {
-			push( @array, undef );
-		}
-		# Now push the k/v parts in a known order.
-		my @fields = qw/ Pers Nb Temps Genre Spec Fonc /;
-		my %props;
-		map { my( $k, $v ) = split( /=/, $_ ); $props{$k} = $v; } @bits;
-		foreach my $k ( @fields ) {
-			push( @array, $props{$k} );
-		}
-		# Give the answer.
-		return @array;
-	} elsif( $self->language eq 'English' ) {
-		# Do something as yet undetermined
-	} else {
-		# Latin or Greek or Armenian, just split the chars
-		return split( '', $self->code );
-	}
-};
+sub throw {
+	Text::Tradition::Error->throw( 
+		'ident' => 'Reading error',
+		'message' => $_[0],
+		);
+}
 
 no Moose;
 __PACKAGE__->meta->make_immutable;
 
 1;
-