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)
has 'id' => (
is => 'ro',
- isa => 'Str',
+ isa => 'ReadingID',
required => 1,
);
has 'language' => (
is => 'ro',
isa => 'Str',
- default => 'Default',
+ predicate => 'has_language',
);
has 'is_start' => (
## 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.
+# Holds the lexemes for the reading.
has 'reading_lexemes' => (
traits => ['Array'],
isa => 'ArrayRef[Text::Tradition::Collation::Reading::Lexeme]',
handles => {
+ lexeme => 'get',
lexemes => 'elements',
has_lexemes => 'count',
clear_lexemes => 'clear',
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'} );
+ }
+}
+
+# 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'
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
=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 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<Text::Tradition::lemmatize> 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 = { @_ };
- }
- if( exists( $args->{'serial'} ) ) {
- my( $lemma, $code ) = split( /!!/, delete $args->{'serial'} );
- $args->{'lemma'} = $lemma;
- $args->{'code'} = $code;
+ # Good to go - add the lexemes.
+ my @lexemes;
+ foreach my $lexhash ( @$data ) {
+ push( @lexemes, Text::Tradition::Collation::Reading::Lexeme->new(
+ 'JSON' => $lexhash ) );
}
- $class->$orig( $args );
-};
+ $self->clear_lexemes;
+ $self->add_lexeme( @lexemes );
+}
-sub serialization {
- my $self = shift;
- return join( '!!', $self->lemma, $self->code );
-};
+## 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;
-