lib/Text/Tradition.pm

   1 package Text::Tradition;
   2
   3 use Module::Load;
   4 use Moose;
   5 use Text::Tradition::Collation;
   6 use Text::Tradition::Witness;
   7
   8 has 'collation' => (
   9     is => 'ro',
  10     isa => 'Text::Tradition::Collation',
  11     writer => '_save_collation',
  12     );
  13
  14 has 'witnesses' => (
  15     traits => ['Array'],
  16     isa => 'ArrayRef[Text::Tradition::Witness]',
  17     handles => {
  18         witnesses    => 'elements',
  19         add_witness  => 'push',
  20     },
  21     default => sub { [] },
  22     );
  23
  24 has 'name' => (
  25     is => 'rw',
  26     isa => 'Str',
  27     default => 'Tradition',
  28     );
  29
  30 around 'add_witness' => sub {
  31     my $orig = shift;
  32     my $self = shift;
  33     my $new_wit = Text::Tradition::Witness->new( @_ );
  34     $self->$orig( $new_wit );
  35     return $new_wit;
  36 };
  37
  38
  39 sub BUILD {
  40     my( $self, $init_args ) = @_;
  41
  42     if( exists $init_args->{'witnesses'} ) {
  43         # We got passed an uncollated list of witnesses.  Make a
  44         # witness object for each witness, and then send them to the
  45         # collator.
  46         my $autosigil = 0;
  47         foreach my $wit ( %{$init_args->{'witnesses'}} ) {
  48             # Each item in the list is either a string or an arrayref.
  49             # If it's a string, it is a filename; if it's an arrayref,
  50             # it is a tuple of 'sigil, file'.  Handle either case.
  51             my $args;
  52             if( ref( $wit ) eq 'ARRAY' ) {
  53                 $args = { 'sigil' => $wit->[0],
  54                           'file' => $wit->[1] };
  55             } else {
  56                 $args = { 'sigil' => chr( $autosigil+65 ),
  57                           'file' => $wit };
  58                 $autosigil++;
  59             }
  60             $self->witnesses->add_witness( $args );
  61             # TODO Now how to collate these?
  62         }
  63     } else {
  64         # Else we need to parse some collation data.  Make a Collation object
  65         my $collation = Text::Tradition::Collation->new( %$init_args,
  66                                                         'tradition' => $self );
  67         $self->_save_collation( $collation );
  68
  69         # Call the appropriate parser on the given data
  70         my @formats = grep { /^(Self|CollateX|CSV|CTE|KUL|TEI|Tabular)$/ } keys( %$init_args );
  71         my $format = shift( @formats );
  72         unless( $format ) {
  73             warn "No data given to create a collation; will initialize an empty one";
  74         }
  75         if( $format && $format =~ /^(KUL)$/ &&
  76             !exists $init_args->{'base'} ) {
  77             warn "Cannot make a collation from $format without a base text";
  78             return;
  79         }
  80
  81         # Now do the parsing.
  82         my @sigla;
  83         if( $format ) {
  84             my @parseargs;
  85             if( $format =~ /^(KUL)$/ ) {
  86                 $init_args->{'data'} = $init_args->{$format};
  87                 $init_args->{'format'} = $format;
  88                 $format = 'BaseText';
  89                 @parseargs = %$init_args;
  90             } else {
  91                 @parseargs = ( $init_args->{ $format } );
  92             }
  93             my $mod = "Text::Tradition::Parser::$format";
  94             load( $mod );
  95             $mod->can('parse')->( $self, @parseargs );
  96         }
  97     }
  98 }
  99
 100 sub witness {
 101     my( $self, $sigil ) = @_;
 102     my $requested_wit;
 103     foreach my $wit ( $self->witnesses ) {
 104         if( $wit->sigil eq $sigil ) {
 105             $requested_wit = $wit;
 106             last;
 107         }
 108     }
 109     # We depend on an undef return value for no such witness.
 110     # warn "No such witness $sigil" unless $requested_wit;
 111     return $requested_wit;
 112 }
 113
 114
 115
 116 # The user will usually be instantiating a Tradition object, and
 117 # examining its collation.  The information about the tradition can
 118 # come via several routes:
 119 # - graphML from CollateX or elsewhere, standalone
 120 # - TEI parallel segmentation
 121 # - Leuven-style spreadsheet of variants, converted to CSV, plus base text
 122 # - apparatus pulled from CTE, plus base text
 123 # From this we should be able to get basic witness information.
 124 #
 125 # Alternatively the user can just give us the uncollated texts.  Then
 126 # instead of passing a collation, s/he is passing a set of witnesses
 127 # from which we will generate a collation.  Those witnesses can be in
 128 # plaintext or in TEI with certain constraints adopted.
 129
 130 # So the constructor for a tradition needs to take one of these infosets,
 131 # and construct the collation and the witness objects.
 132
 133 no Moose;
 134 __PACKAGE__->meta->make_immutable;