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
=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.
=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
has 'id' => (
is => 'ro',
- isa => 'Str',
+ isa => 'ReadingID',
required => 1,
);
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',
+ predicate => 'has_language',
);
-
+
has 'is_start' => (
is => 'ro',
isa => 'Bool',
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 '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',
+ clearer => '_clear_normal_form',
+ );
+
+# 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',
+ add_lexeme => 'push',
+ },
+ default => sub { [] },
+ );
+
+## For prefix/suffix readings
+
+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',
+ );
around BUILDARGS => sub {
} else {
$args = { @_ };
}
-
+
# 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 );
};
-# Post-process the given text, stripping punctuation if we are asked.
+# Look for a lexeme-string argument in the build args.
sub BUILD {
- my $self = shift;
- if( $self->separate_punctuation && !$self->is_meta ) {
- 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 );
+ my( $self, $args ) = @_;
+ if( exists $args->{'lexemes'} ) {
+ $self->_deserialize_lexemes( $args->{'lexemes'} );
}
}
-sub punctuated_form {
+# Make normal_form default to text, transparently.
+around 'normal_form' => sub {
+ my $orig = shift;
my $self = shift;
- my $word = $self->text;
- foreach my $p ( sort { $a->{pos} <=> $b->{pos} } $self->punctuation ) {
- substr( $word, $p->{pos}, 0, $p->{char} );
+ 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( @_ );
}
- return $word;
-}
+};
=head2 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,
return $self->id;
}
+=head1 MORPHOLOGY
+
+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 lemmatize
+
+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 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;
+
+ # 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 ) );
+ }
+ $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
+
+sub TO_JSON {
+ my $self = shift;
+ return $self->text;
+}
+
+sub throw {
+ Text::Tradition::Error->throw(
+ 'ident' => 'Reading error',
+ 'message' => $_[0],
+ );
+}
+
no Moose;
__PACKAGE__->meta->make_immutable;
1;
-
projects / scpubgit/stemmatology.git / blobdiff