File Coverage

blib/lib/TeX/AutoTeX.pm

Criterion	Covered	Total	%
statement	27	89	30.3
branch	0	42	0.0
condition	0	18	0.0
subroutine	9	13	69.2
pod	3	3	100.0
total	39	165	23.6

package TeX::AutoTeX;

#
# $Id: AutoTeX.pm,v 1.20.2.7 2011/01/27 18:56:29 thorstens Exp $
# $Revision: 1.20.2.7 $
# $Source: /cvsroot/arxivlib/arXivLib/lib/TeX/AutoTeX.pm,v $
#
# $Date: 2011/01/27 18:56:29 $
# $Author: thorstens $
#

use strict;
### use warnings;
use Carp;

# our ($VERSION) = '$Revision: 1.20.2.7 $' =~ m{ \$Revision: \s+ (\S+) }x;
our $VERSION = 'v0.906.0';

use TeX::AutoTeX::Config qw(
			     $AUTOTEX_ENV_PATH
			     $DEFAULTPSRESOLUTION
			     $DEFAULT_BRANCH
			     $DEFAULT_TEX_BIN_PATH
			  );
use TeX::AutoTeX::Fileset;
use TeX::AutoTeX::File;
use TeX::AutoTeX::Log;
use TeX::AutoTeX::Process;
use TeX::AutoTeX::Mail;

use parent qw(Class::Accessor::Fast);
__PACKAGE__->follow_best_practice();
__PACKAGE__->mk_accessors(
			  qw(
			      workdir
			      branch
			      use_stamp
			      stampref
			      log
			      verbose
			      send_email
			      dvips_paper_type
			      dvips_resolution
			      dvips_printer
			      dvips_mapfile
			      output_format
			      is_pdftex
			      tex_env_path
			   )
			 );

sub new {
  my $class = shift;
  my $self = {
	      workdir     => undef,
	      branch      => undef,
	      use_stamp   => 1,
	      stampref    => undef,
	      log         => undef,
	      send_email  => 0,
	      verbose     => undef,
	      dvips_paper_type => undef,
	      dvips_resolution => $DEFAULTPSRESOLUTION,
	      dvips_printer    => undef,
	      dvips_mapfile    => undef,
	      @_,
	     };
  if (!defined $self->{workdir}) {
    croak 'no directory holding the unpacked source material defined';
  }
  if ($self->{workdir} ne 'will be derived from paper id'
      && (stat $self->{workdir})[2] != oct(40777)
      && (stat(_))[2] != oct(40775)) {
    croak "workdir '$self->{workdir}' is not a directory or doesn't have mode 0777 or 0775";
  }

  bless $self, $class;
}

sub process {
  my $self = shift;

  local ($?, $!, $@);

  if (!$self->{branch}) { # use the latest branch, unless specified otherwise
    $self->{branch} = $DEFAULT_BRANCH;
    $self->{tex_env_path} = $DEFAULT_TEX_BIN_PATH;
    local $ENV{TEXMFCNF} = q{}; # prevent inadvertent problems due to user settings
  }
  if (ref $self->{log} ne 'TeX::AutoTeX::Log') {
    $self->{log} = TeX::AutoTeX::Log->new(
					  dir     => $self->{workdir},
					  verbose => $self->{verbose},
					  dupefh  => $self->{verbose} ? \*STDOUT : undef,
					 );
  }

  my $p = $self->{process} =
    TeX::AutoTeX::Process->new(
			       log      => $self->{log},
			       fileset  => $self->{fileset},
			       temp_dir => $self->{workdir},
			       branch   => $self->{branch},
			       stampref => $self->{stampref},
			       use_stamp      => $self->{use_stamp},
			       decryption_key => $self->{decryption_key},
			       tex_env_path   => $self->{tex_env_path}? $self->{tex_env_path}
			                                              : "/$self->{branch}/bin:/bin",
			      );

  if ($self->__combine_dvips_flags()) {
    $p->set_dvi_flags(@{$self->{dvi_flags}})
  }

  if (ref $self->{stampref} ne 'ARRAY') {
    $p->{use_stamp} = 0;
  }

  local $ENV{PATH} = $AUTOTEX_ENV_PATH; # also untaints path

  if ($p->{error} = $p->go()) {
    $self->{log}->verbose("AutoTeX returned error: $p->{error}");
    # optionally send failure notification email to admin
    if ($self->{send_email}) {
      $self->email();
      }
    return;
  }
  if (@{$p->{made_pdf}}) {
    $self->{log}->verbose('PDFTEX paper, check "'
			  . ($self->{paper} ? $self->{paper} : $self->{workdir})
			  . qq{".\n});
    $self->set_is_pdftex(1);
  }

  $self->{log}->verbose("All done.\n");
  return 1;
}

sub __combine_dvips_flags {
  my $self = shift;
  $self->{dvi_flags} = [];
  if ($self->{dvips_paper_type} && $self->{dvips_paper_type} =~ /^([a-z0-9]+)$/i) {
    push @{$self->{dvi_flags}}, "-t $1";
  }
  if (defined $self->{dvips_printer}) {
    if ($self->{dvips_printer} =~ /(?:type1|pdf)/i) {
      push @{$self->{dvi_flags}}, '-P type1';
      $self->{output_format} = 'fInm';
    } elsif ($self->{dvips_printer} eq 'pk') {
      # TS: new for texlive 12/2009
      push @{$self->{dvi_flags}}, '-P pk';
    }
  }
  if ($self->{dvips_resolution} && $self->{dvips_resolution} =~ /^([346]00)$/) {
    if ($1 != $DEFAULTPSRESOLUTION) {
      push @{$self->{dvi_flags}}, "-D $1";
      $self->{output_format} ||= "d$1"; # don't overwrite 'fInm'
    }
  }
  if ($self->{dvips_mapfile} && $self->{dvips_mapfile} =~ /^\+?([a-z]+\.map)$/i) {
    push @{$self->{dvi_flags}}, "-u +$1";
  }
  return wantarray ? @{$self->{dvi_flags}} : scalar @{$self->{dvi_flags}};
}

sub email {
  my $self = shift;

  my $dvips_options = $self->{process}->dvi_flags_tostring();

  my $mailer = TeX::AutoTeX::Mail->new($self->{workdir});
  if (my $msg = $mailer->send_failure("Failure for $self->{workdir}", <<"EOM")
 $self->{workdir} failed autotex,
 dvips run with options '$dvips_options'.

 $self->{process}->{error}
EOM
     ) {
    $self->{log}->verbose("send_failure error: $msg");
  }
  return;
}

1;

__END__