X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FText%2FTradition%2FCollation%2FReading.pm;h=47bd0f708af8d25f8da759b7a52fc9d0c4b7733a;hb=cca4f996c756a6989b0c38aa13f974b31f3da54a;hp=6664fee189231000bfa6b6ab8047f8d3f363d4d2;hpb=a731e73a29eb1faeee2db782961c8ebe1f67239f;p=scpubgit%2Fstemmatology.git

diff --git a/lib/Text/Tradition/Collation/Reading.pm b/lib/Text/Tradition/Collation/Reading.pm
index 6664fee..47bd0f7 100644
--- a/lib/Text/Tradition/Collation/Reading.pm
+++ b/lib/Text/Tradition/Collation/Reading.pm
@@ -5,8 +5,9 @@ use overload '""' => \&_stringify, 'fallback' => 1;
 
 =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 +20,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 +38,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
 
@@ -82,22 +86,12 @@ has 'text' => (
 	writer => 'alter_text',
 	);
 	
-has 'punctuation' => (
-	traits => ['Array'],
-	isa => 'ArrayRef[HashRef[Str]]',
-	default => sub { [] },
-	handles => {
-			punctuation => 'elements',
-			add_punctuation => 'push',
-			},
-	);
-
-has 'separate_punctuation' => (
+has 'language' => (
 	is => 'ro',
-	isa => 'Bool',
-	default => 1,
+	isa => 'Str',
+	default => 'Default',
 	);
-
+	
 has 'is_start' => (
 	is => 'ro',
 	isa => 'Bool',
@@ -121,12 +115,54 @@ has 'is_ph' => (
 	isa => 'Bool',
 	default => undef,
 	);
+	
+has 'is_common' => (
+	is => 'rw',
+	isa => 'Bool',
+	default => undef,
+	);
 
 has 'rank' => (
     is => 'rw',
     isa => 'Int',
     predicate => 'has_rank',
+    clearer => 'clear_rank',
     );
+    
+## For morphological analysis
+
+has 'normal_form' => (
+	is => 'rw',
+	isa => 'Str',
+	predicate => 'has_normal_form',
+	);
+
+# Holds the word form. If is_disambiguated is true, the form at index zero
+# is the correct one.
+has 'lexemes' => (
+	traits => ['Array'],
+	isa => 'ArrayRef[Text::Tradition::Collation::Lexeme]',
+	handles => {
+		lexemes => 'elements',
+		has_lexemes => 'count',
+		_clear_lexemes => 'clear',
+		_add_lexeme => 'push',
+		},
+	);
+	
+## For prefix/suffix readings
+
+has 'join_prior' => (
+	is => 'ro',
+	isa => 'Bool',
+	default => undef,
+	);
+	
+has 'join_next' => (
+	is => 'ro',
+	isa => 'Bool',
+	default => undef,
+	);
 
 
 around BUILDARGS => sub {
@@ -138,26 +174,7 @@ around BUILDARGS => sub {
 	} else {
 		$args = { @_ };
 	}
-	
-	# Did we get a JSON token to parse into a reading?  If so, massage it.
-	if( exists $args->{'json'} ) {
-		my $j = delete $args->{'json'};
-
-		# If we have separated punctuation and don't want it, restore it.
-		if( exists $j->{'punctuation'}
-			&& exists $args->{'separate_punctuation'}
-			&& !$args->{'separate_punctuation'} ) {
-			$args->{'text'} = _restore_punct( $j->{'t'}, $j->{'punctuation'} );
-
-		# In all other cases, keep text and punct as they are.
-		} else {
-			$args->{'text'} = $j->{'t'};
-			# we don't use comparison or canonical forms here
-			$args->{'punctuation'} = $j->{'punctuation'}
-				if exists $j->{'punctuation'};
-		}
-	}
-		
+			
 	# If one of our special booleans is set, we change the text and the
 	# ID to match.
 	if( exists $args->{'is_lacuna'} && !exists $args->{'text'} ) {
@@ -176,38 +193,6 @@ around BUILDARGS => sub {
 	$class->$orig( $args );
 };
 
-# Post-process the given text, stripping punctuation if we are asked.
-sub BUILD {
-	my $self = shift;
-	if( $self->separate_punctuation && !$self->is_meta
-		&& !$self->punctuation ) {
-		my $pos = 0;
-		my $wspunct = '';  # word sans punctuation
-		foreach my $char ( split( //, $self->text ) ) {
-			if( $char =~ /^[[:punct:]]$/ ) {
-				$self->add_punctuation( { 'char' => $char, 'pos' => $pos } );
-			} else {
-				$wspunct .= $char;
-			}
-			$pos++;
-		}
-		$self->alter_text( $wspunct );
-	}
-}
-
-sub punctuated_form {
-	my $self = shift;
-	return _restore_punct( $self->text, $self->punctuation );
-}
-
-sub _restore_punct {
-	my( $word, @punct ) = @_;
-	foreach my $p ( sort { $a->{pos} <=> $b->{pos} } @punct ) {
-		substr( $word, $p->{pos}, 0, $p->{char} );
-	}
-	return $word;
-}	
-
 =head2 is_meta
 
 A meta attribute (ha ha), which should be true if any of our 'special'
@@ -221,24 +206,61 @@ sub is_meta {
 	return $self->is_start || $self->is_end || $self->is_lacuna || $self->is_ph;	
 }
 
-# Some syntactic sugar
+=head1 Convenience methods
+
+=head2 related_readings
+
+Calls Collation's related_readings with $self as the first argument.
+
+=cut
+
 sub related_readings {
 	my $self = shift;
 	return $self->collation->related_readings( $self, @_ );
 }
 
+=head2 witnesses 
+
+Calls Collation's reading_witnesses with $self as the first argument.
+
+=cut
+
+sub witnesses {
+	my $self = shift;
+	return $self->collation->reading_witnesses( $self, @_ );
+}
+
+=head2 predecessors
+
+Returns a list of Reading objects that immediately precede $self in the collation.
+
+=cut
+
 sub predecessors {
 	my $self = shift;
 	my @pred = $self->collation->sequence->predecessors( $self->id );
 	return map { $self->collation->reading( $_ ) } @pred;
 }
 
+=head2 successors
+
+Returns a list of Reading objects that immediately follow $self in the collation.
+
+=cut
+
 sub successors {
 	my $self = shift;
 	my @succ = $self->collation->sequence->successors( $self->id );
 	return map { $self->collation->reading( $_ ) } @succ;
 }
 
+=head2 set_identical( $other_reading)
+
+Backwards compatibility method, to add a transposition relationship
+between $self and $other_reading.  Don't use this.
+
+=cut
+
 sub set_identical {
 	my( $self, $other ) = @_;
 	return $self->collation->add_relationship( $self, $other, 
@@ -250,6 +272,143 @@ sub _stringify {
 	return $self->id;
 }
 
+=head1 MORPHOLOGY
+
+A few methods to try to tack on morphological information.
+
+=head2 use_lexemes
+
+TBD
+
+=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 );
+# 		return;
+# 	}
+# 	$self->_clear_morph;
+# 	map { $self->_add_morph( { $_ => [] } ) } @lexemes;
+# }
+# 
+# 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 );
+# }
+
+## Utility methods
+
+sub TO_JSON {
+	my $self = shift;
+	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 );
+	}
+};
+
 no Moose;
 __PACKAGE__->meta->make_immutable;