X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FText%2FTradition%2FCollation%2FReading.pm;h=f445420829ba97d6230bc5d2d1f958cc2530ea8a;hb=378de72495d704d9de710a0b9c6cfec146de7886;hp=47bd0f708af8d25f8da759b7a52fc9d0c4b7733a;hpb=cca4f996c756a6989b0c38aa13f974b31f3da54a;p=scpubgit%2Fstemmatology.git diff --git a/lib/Text/Tradition/Collation/Reading.pm b/lib/Text/Tradition/Collation/Reading.pm index 47bd0f7..f445420 100644 --- a/lib/Text/Tradition/Collation/Reading.pm +++ b/lib/Text/Tradition/Collation/Reading.pm @@ -1,8 +1,21 @@ 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) @@ -75,7 +88,7 @@ has 'collation' => ( has 'id' => ( is => 'ro', - isa => 'Str', + isa => 'ReadingID', required => 1, ); @@ -89,7 +102,7 @@ has 'text' => ( has 'language' => ( is => 'ro', isa => 'Str', - default => 'Default', + predicate => 'has_language', ); has 'is_start' => ( @@ -131,23 +144,37 @@ has 'rank' => ( ## For morphological analysis +has 'grammar_invalid' => ( + is => 'rw', + isa => 'Bool', + default => undef, + ); + +has 'is_nonsense' => ( + is => 'rw', + isa => 'Bool', + default => undef, + ); + has 'normal_form' => ( is => 'rw', isa => 'Str', - predicate => 'has_normal_form', + predicate => '_has_normal_form', + clearer => '_clear_normal_form', ); -# Holds the word form. If is_disambiguated is true, the form at index zero -# is the correct one. -has 'lexemes' => ( +# Holds the lexemes for the reading. +has 'reading_lexemes' => ( traits => ['Array'], - isa => 'ArrayRef[Text::Tradition::Collation::Lexeme]', + isa => 'ArrayRef[Text::Tradition::Collation::Reading::Lexeme]', handles => { + lexeme => 'get', lexemes => 'elements', has_lexemes => 'count', - _clear_lexemes => 'clear', - _add_lexeme => 'push', + clear_lexemes => 'clear', + add_lexeme => 'push', }, + default => sub { [] }, ); ## For prefix/suffix readings @@ -156,12 +183,14 @@ has 'join_prior' => ( is => 'ro', isa => 'Bool', default => undef, + writer => '_set_join_prior', ); has 'join_next' => ( is => 'ro', isa => 'Bool', default => undef, + writer => '_set_join_next', ); @@ -177,22 +206,54 @@ around BUILDARGS => sub { # 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'} ) { + if( exists $args->{'is_lacuna'} && $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 + } elsif( exists $args->{'is_start'} && $args->{'is_start'} ) { + $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 + } elsif( exists $args->{'is_end'} && $args->{'is_end'} ) { + $args->{'id'} = '__END__'; # Change the ID to ensure we have only one $args->{'text'} = '#END#'; - } elsif( exists $args->{'is_ph'} ) { + } elsif( exists $args->{'is_ph'} && $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'} ); + } +} + +# Make normal_form default to text, transparently. +around 'normal_form' => sub { + my $orig = shift; + my $self = shift; + my( $arg ) = @_; + if( $arg && $arg eq $self->text ) { + $self->_clear_normal_form; + return $arg; + } elsif( !$arg && !$self->_has_normal_form ) { + return $self->text; + } else { + $self->$orig( @_ ); + } +}; + =head2 is_meta A meta attribute (ha ha), which should be true if any of our 'special' @@ -274,143 +335,99 @@ 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 for more information +on Lexeme objects and their attributes. -=head2 use_lexemes +=head2 has_lexemes -TBD +Returns a true value if the reading has any attached lexemes. -=cut +=head2 lexemes -# 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 ); -# } +Returns the Lexeme objects (if any) attached to the reading. -## Utility methods +=head2 clear_lexemes -sub TO_JSON { - my $self = shift; - return $self->text; -} +Wipes any associated Lexeme objects out of the reading. -## TODO will need a throw() here +=head2 add_lexeme( $lexobj ) -no Moose; -__PACKAGE__->meta->make_immutable; +Adds the Lexeme in $lexobj to the list of lexemes. -################################################### -### Morphology objects, to be attached to readings -################################################### +=head2 lemmatize -package Text::Tradition::Collation::Reading::Morphology; +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 if you wish to lemmatize an entire tradition. -use Moose; +=cut -has 'lemma' => ( - is => 'ro', - isa => 'Str', - required => 1, - ); - -has 'code' => ( - is => 'ro', - isa => 'Str', - required => 1, - ); +sub lemmatize { + my $self = shift; + unless( $self->has_language ) { + warn "Please set a language to lemmatize a tradition"; + return; + } + my $mod = "Text::Tradition::Language::" . $self->language; + load( $mod ); + $mod->can( 'reading_lookup' )->( $self ); + +} + +# 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 ] ); +} + +# 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; -has 'language' => ( - is => 'ro', - isa => 'Str', - required => 1, - ); + # Need to have the lexeme module in order to have lexemes. + eval { use Text::Tradition::Collation::Reading::Lexeme; }; + throw( $@ ) if $@; -## 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 = { @_ }; + # Good to go - add the lexemes. + my @lexemes; + foreach my $lexhash ( @$data ) { + push( @lexemes, Text::Tradition::Collation::Reading::Lexeme->new( + 'JSON' => $lexhash ) ); } - if( exists( $args->{'serial'} ) ) { - my( $lemma, $code ) = split( /!!/, delete $args->{'serial'} ); - $args->{'lemma'} = $lemma; - $args->{'code'} = $code; - } - $class->$orig( $args ); -}; + $self->clear_lexemes; + $self->add_lexeme( @lexemes ); +} -sub serialization { +sub disambiguated { my $self = shift; - return join( '!!', $self->lemma, $self->code ); -}; + return 0 unless $self->has_lexemes; + return !grep { !$_->is_disambiguated } $self->lexemes; +} + +## Utility methods -sub comparison_array { +sub TO_JSON { 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 ); - } -}; + return $self->text; +} + +sub throw { + Text::Tradition::Error->throw( + 'ident' => 'Reading error', + 'message' => $_[0], + ); +} no Moose; __PACKAGE__->meta->make_immutable; 1; -