Merge branch 'master' of github.com:tla/stemmatology

[scpubgit/stemmatology.git] / lib / Text / Tradition / Collation / Reading.pm

diff --git a/lib/Text/Tradition/Collation/Reading.pm b/lib/Text/Tradition/Collation/Reading.pm
index 29a8aa1..f445420 100644 (file)
--- a/lib/Text/Tradition/Collation/Reading.pm
+++ b/lib/Text/Tradition/Collation/Reading.pm
@@ -1,10 +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)
@@ -77,7 +88,7 @@ has 'collation' => (
 
 has 'id' => (
        is => 'ro',
-       isa => 'Str',
+       isa => 'ReadingID',
        required => 1,
        );
 
@@ -133,10 +144,23 @@ 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 lexemes for the reading.
@@ -144,6 +168,7 @@ has 'reading_lexemes' => (
        traits => ['Array'],
        isa => 'ArrayRef[Text::Tradition::Collation::Reading::Lexeme]',
        handles => {
+               lexeme => 'get',
                lexemes => 'elements',
                has_lexemes => 'count',
                clear_lexemes => 'clear',
@@ -158,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',
        );
 
 
@@ -179,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'
@@ -319,23 +378,40 @@ sub lemmatize {
 
 }
 
-# For graph serialization. Return a string representation of the associated
+# For graph serialization. Return a JSON representation of the associated
 # reading lexemes.
 sub _serialize_lexemes {
        my $self = shift;
-       my @lexstrs;
-       foreach my $l ( $self->lexemes ) {
-               my @mf;
-               foreach my $wf ( $l->matching_forms ) {
-                       push( @mf, $wf->to_string );
-               }
-               my $form = $l->form ? $l->form->to_string : '';
-               push( @lexstrs, join( '|L|', $l->language, $l->string, $form, 
-                       join( '|M|', @mf ) ) );
+       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;
+       
+       # 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 join( '|R|', @lexstrs );
+       $self->clear_lexemes;
+       $self->add_lexeme( @lexemes );
+}
+
+sub disambiguated {
+       my $self = shift;
+       return 0 unless $self->has_lexemes;
+       return !grep { !$_->is_disambiguated } $self->lexemes;
 }
-               
 
 ## Utility methods
 
@@ -344,7 +420,12 @@ sub TO_JSON {
        return $self->text;
 }
 
-## TODO will need a throw() here
+sub throw {
+       Text::Tradition::Error->throw( 
+               'ident' => 'Reading error',
+               'message' => $_[0],
+               );
+}
 
 no Moose;
 __PACKAGE__->meta->make_immutable;