JezK
Edit File: ctanify
#!/usr/bin/perl # Debian required shebang above # Original shebang below # #! /usr/bin/env perl ################################################ # Prepare a LaTeX package for upload to CTAN # # By Scott Pakin <scott+ctify@pakin.org> # ################################################ use Cwd; use File::Basename; use File::Copy::Recursive qw(fcopy); use File::Find; use File::Path; use File::Spec; use File::stat; use File::Temp qw(tempdir); use Getopt::Long; use Pod::Usage; use warnings; use strict; # Define some global variables. our $VERSION = "1.9.1"; # ctanify version number my $progname = basename $0; # Name of this program my $pkgname; # Base name of the package to create my $miscify = 0; # 1=replace singletons with misc; 0=don't my $autoinclude = 1; # 1=automatically include files named in .ins my $skipdroppings = 1; # 1=skip "dropping" files (e.g., "README~") my $unixify = 1; # 1=make text files use Unix line endings my $maketds = 1; # 1=embed a .tds.zip file; 0=don't my @manifest; # List of files to include my %file2tds; # Map from specific filenames to TDS directories my @tdsdirlist; # Contents of the TDS tree my @pkgdirlist; # Contents of the package tree my @tdsonly; # Files to include only in the TDS tree my $tdsdir = ""; # Absolute directory of the TDS tree my $pkgdir = ""; # Absolute directory of the package directory my $zipname; # Name of the TDS zip file my $tarname; # Name of the package tar file my $tdsoutdir; # Directory name where to output TDS tree my $texmacros = "latex"; # TeX macro package # Associate file extensions with TDS directories. "%s" is replaced # with the package name. my %ext2tds = ("README" => "doc/latex/%s", "afm" => "fonts/afm/public/%s", "bat" => "scripts/%s", "bbx" => "tex/latex/%s", "bib" => "bibtex/bib/%s", "bst" => "bibtex/bst/%s", "cbx" => "tex/latex/%s", "cls" => "tex/latex/%s", "dbx" => "tex/latex/%s", "dtx" => "source/latex/%s", "dvi" => "doc/latex/%s", "fd" => "tex/latex/%s", "ins" => "source/latex/%s", "map" => "fonts/map/dvips/%s", "md" => "doc/latex/%s", "mf" => "fonts/source/public/%s", "mp" => "metapost/%s", "ofm" => "fonts/ofm/public/%s", "ovf" => "fonts/ovf/public/%s", "ovp" => "fonts/ovp/public/%s", "pdf" => "doc/latex/%s", "pfb" => "fonts/type1/public/%s", "pfm" => "fonts/type1/public/%s", "ps" => "doc/latex/%s", "py" => "scripts/%s", "sh" => "scripts/%s", "sty" => "tex/latex/%s", "tfm" => "fonts/tfm/public/%s", "txt" => "doc/latex/%s", "vf" => "fonts/vf/public/%s"); # Specify a list of filename regexps to ignore. my @ignore_re = ('~$', '\bCVS\b', '\b\.svn\b'); # Specify a list of file extensions that are considered "text" files. # This script will convert their line endings to Unix style (a single # linefeed character). my %text_ext = map {($_ => 1)} qw(afm bib bst cls dtx fd ins ltx md mf mp sty tex txt); # Define a subroutine that returns the size in bytes of a file, # aborting on error. sub filesize ($) { my $finfo = lstat($_[0]) || die "${progname}: Failed to stat $_ ($!)\n"; return $finfo->size; } # Define a subroutine that runs a command and aborts on error. sub run_command ($;$) { my $command = $_[0]; my $ignore_errors = defined $_[1] ? $_[1] : 0; my $retval = system $command; if (!$ignore_errors && $retval>>8) { die "${progname}: Command \"$command\" failed\n"; } } # Define a subroutine that Unix-ifies the line endings in text files. # This subroutine is called from File::Find so it does not accept # arguments via the @_ variable. my %reported_line_endings; # Files we converted and told the user about sub use_unix_line_endings { # Determine if the file is a text file. my $fname = $_; return if !-f $fname; my $fext = ($fname =~ m|([^./]+)$| && $1); return if !defined $text_ext{$fext}; # Make it use Unix line endings. Note that we don't bother # checking if we're already on a Unix (or Unix-like) system. my $oldsize = filesize $fname; open(TEXTFILE, "<$fname") || die "${progname}: Failed to open $File::Find::name ($!)\n"; my @entirefile = map {s/[\n\r]+$/\n/; $_} <TEXTFILE>; close TEXTFILE; open(BINARYFILE, ">$fname") || die "${progname}: Failed to open $File::Find::name ($!)\n"; binmode BINARYFILE; print BINARYFILE @entirefile; close BINARYFILE; my $newsize = filesize $fname; if ($newsize != $oldsize && !defined $reported_line_endings{$fname}) { # Don't frighten the user when he sees a different file size # in the tar file from the original in the filesystem my $fullname = $File::Find::name; $fullname =~ s,^$tdsdir/,,; $fullname =~ s,^$pkgdir/,,; warn "${progname}: Modified $fullname to use Unix line endings (use --no-unixify to prevent this)\n"; $reported_line_endings{$fname} = 1; } } ########################################################################### # Parse the command line. my $wanthelp = 0; my $wantversion = 0; GetOptions("p|pkgname=s" => \$pkgname, "m|misc!" => \$miscify, "k|skip!" => \$skipdroppings, "u|unixify!" => \$unixify, "t|tdsonly=s" => \@tdsonly, "a|auto!" => \$autoinclude, "d|tdsdir=s" => \$tdsoutdir, "T|tex=s" => \$texmacros, "s|tds!" => \$maketds, "V|version" => \$wantversion, "h|help" => \$wanthelp) || pod2usage(-verbose => 0, -exitval => 1); pod2usage(-verbose => 1, -exitval => 0) if $wanthelp; if ($wantversion) { print "ctanify version $VERSION\n"; exit 0; } pod2usage(-verbose => 0, -exitval => 1) if !@ARGV; foreach my $fname (@ARGV) { # Let the user specify "<filename>=<dirname>" to place files # explicitly in the TDS tree. if ($fname =~ /^(.*)=([^=]+)$/) { foreach my $exp_fname (glob $1) { $file2tds{$exp_fname} = $2; push @manifest, $exp_fname; } } else { push @manifest, glob $fname; } } @tdsonly = map {File::Spec->abs2rel($_)} map {glob} @tdsonly; # Replace "latex" with something else if --tex was specified. if ($texmacros ne "latex") { foreach my $ext (keys %ext2tds) { $ext2tds{$ext} =~ s,\blatex\b,$texmacros,g; } } # Determine the package name if not explicitly specified. if (!defined $pkgname) { my @mainfiles = (grep(/\.ins$/, @manifest), grep(/\.sty$/, @manifest)); if (!@mainfiles) { die "${progname}: Please either list a .ins or .sty file or specify --pkgname\n"; } $pkgname = basename $mainfiles[0]; $pkgname =~ s/\.[^.]+$//; } # Parse each .ins file to find more files to include. if ($autoinclude) { foreach my $fname (grep /\.ins$/, @manifest) { # Read the entire file. local $/ = undef; open(INSFILE, "<$fname") || die "${progname}: Failed to open $fname ($!)\n"; my $insfile = <INSFILE>; close INSFILE; $insfile =~ s/\%.*?\n//g; # Add all source files (\from) to the manifest. while ($insfile =~ /\\from\{([^\}]+)\}/g) { my $fname_exp = $1; $fname_exp =~ s/\\jobname\b/$pkgname/g; push @manifest, $fname_exp; } # Add all generated files (\file) to the manifest but also to # the list of TDS-only inclusions. while ($insfile =~ /\\file\{([^\}]+)\}/g) { my $fname_exp = $1; $fname_exp =~ s/\\jobname\b/$pkgname/g; push @manifest, $fname_exp; push @tdsonly, $fname_exp; } } } # Skip "dropping" files and files beginning with ".". if ($skipdroppings) { my @newmanifest; CHECK_DROPPING: foreach my $fname (@manifest) { if (substr($fname, 0, 1) eq ".") { warn "${progname}: Excluding $fname (use --no-skip to force inclusion)\n"; next CHECK_DROPPING; } foreach my $dropping_re (@ignore_re) { if ($fname =~ $dropping_re) { warn "${progname}: Excluding $fname (use --no-skip to force inclusion)\n"; next CHECK_DROPPING; } } push @newmanifest, $fname; } @manifest = @newmanifest; } # Map each file to a TDS directory. foreach my $fname (@manifest) { next if defined $file2tds{$fname}; my $fext = ($fname =~ m|([^./]+)$| && $1); if ($fname =~ /\.tex$/ && $pkgname eq basename $fname, ".tex") { # <package>.tex -- treat as documentation. $file2tds{$fname} = sprintf $ext2tds{"README"}, $pkgname; } elsif (defined $ext2tds{$fext}) { # Most files -- determine the directory based on the file extension. $file2tds{$fname} = sprintf $ext2tds{$fext}, $pkgname; } elsif ($fext =~ /^(\d+)[a-z]*$/i) { # Man page (e.g., "ls.1" or "File::Temp.3pm"). $file2tds{$fname} = "doc/man/man$1"; } else { # Read the file to determine if it's a Unix script (starts with "#!"). open(SCRIPT, "<", $fname) || die "${progname}: Failed to open $fname ($!)\n"; my $shebang; read(SCRIPT, $shebang, 2); close SCRIPT; if ($shebang eq "#!") { $file2tds{$fname} = "scripts/$pkgname"; } else { warn "${progname}: Not including $fname in the TDS tree (unknown extension)\n"; } } } # Create a working directory and populate it with TDS files. my $workdir = tempdir("$progname-XXXXXX", TMPDIR => 1, CLEANUP => 1); $tdsdir = $tdsoutdir ? $tdsoutdir : "$workdir/texmf"; mkdir $tdsdir || die "${progname}: Failed to create $tdsdir ($!)\n"; foreach my $fname (@manifest) { # Create a TDS subdirectory. my $subdir = $file2tds{$fname}; next if !defined $subdir; mkpath "$tdsdir/$subdir"; # Copy the specified file into the subdirectory. fcopy($fname, "$tdsdir/$subdir/" . basename $fname) || die "${progname}: Failed to copy $fname ($!)\n"; } if ($miscify) { # Replace package directories containing a single file with "misc". my %renamings; find(sub { return if $File::Find::name =~ m|\btexmf/fonts\b|; if (-d) { my @children = glob "$_/*"; if ($#children == 0 && -f $children[0] && $_ eq $pkgname) { $renamings{$File::Find::name} = $File::Find::dir . "/misc"; } } }, $tdsdir); while (my ($oldname, $newname) = each %renamings) { rename $oldname, $newname; } } if ($unixify) { # Make all text files use Unix line endings. find(\&use_unix_line_endings, $tdsdir); } # Complain if the doc directory contains PostScript or DVI files. my @bad_docs; find(sub { return if !-f; push @bad_docs, $_ if $File::Find::name =~ m,\bdoc/[^/]+/$pkgname/.*\.(ps|dvi)$,; }, $tdsdir); if (@bad_docs) { my $bad_docs = join ", ", @bad_docs; warn "${progname}: CTAN prefers having only PDF documentation (re: $bad_docs)\n"; } # We have no more work to do if we're simply creating a TDS directory. exit 0 if $tdsoutdir; # Store a listing of the TDS directory. my $prevdir = getcwd(); chdir $tdsdir || die "${progname}: Failed to switch to $tdsdir ($!)\n"; find(sub { return if !-f; my $fsize = filesize $_; push @tdsdirlist, [substr($File::Find::name, 2), $fsize]; }, "."); # Archive and remove the TDS directory. $zipname = "$pkgname.tds.zip"; my $zip_exclusions = $skipdroppings ? "-x __MACOSX -x .DS_Store" : ""; run_command "zip -q -r -9 -y -m $workdir/$zipname . $zip_exclusions", 1; my $zipsize; if (-f "$workdir/$zipname") { $zipsize = filesize "$workdir/$zipname"; } else { $zipname = ""; } $zipname = "" if !$maketds; chdir $prevdir || die "${progname}: Failed to switch to $prevdir ($!)\n"; rmdir $tdsdir || die "${progname}: Failed to remove $tdsdir ($!)\n"; # Copy all files named in the file manifest to the package directory. $pkgdir = "$workdir/$pkgname"; mkdir $pkgdir || die "${progname}: Failed to create $pkgdir ($!)\n"; my %tdsonly = map {($_ => 1)} @tdsonly; foreach my $fname (@manifest) { my $relname = File::Spec->abs2rel($fname); next if defined $tdsonly{$relname}; my ($namepart, $pathpart, $suffixpart) = fileparse($relname); mkpath "$pkgdir/$pathpart"; my $targetfile = "$pkgdir/$pathpart/$namepart$suffixpart"; fcopy($fname, $targetfile) || die "${progname}: Failed to copy $fname ($!)\n"; } if ($unixify) { # Make all text files use Unix line endings. find(\&use_unix_line_endings, $pkgdir); } # Store a listing of the package directory. $prevdir = getcwd(); chdir $pkgdir || die "${progname}: Failed to switch to $pkgdir ($!)\n"; find(sub { return if !-f; my $fsize = filesize $_; push @pkgdirlist, [substr($File::Find::name, 2), $fsize]; }, "."); chdir $prevdir || die "${progname}: Failed to switch to $prevdir ($!)\n"; # Tar up the package directory. $tarname = "$pkgname.tar.gz"; my $tar_exclusions = $skipdroppings ? "--exclude=__MACOSX --exclude=.DS_Store" : ""; run_command "tar -czf $tarname -C $workdir $tar_exclusions $pkgname $zipname"; # Output a listing of what we tarred up. printf "\n%8d %s\n\n", filesize($tarname), $tarname; foreach my $fname_size (sort {$a->[0] cmp $b->[0]} @pkgdirlist) { my ($fname, $fsize) = @$fname_size; printf " %8d %s/%s\n", $fsize, $pkgname, $fname; } if ($zipname ne "") { printf " %8d %s\n\n", $zipsize, $zipname; foreach my $fname_size (sort {$a->[0] cmp $b->[0]} @tdsdirlist) { my ($fname, $fsize) = @$fname_size; printf " %8d %s\n", $fsize, $fname; } } print "\n"; ########################################################################### __END__ =head1 NAME ctanify - Prepare a package for upload to CTAN =head1 SYNOPSIS ctanify [B<--pkgname>=I<string>] [B<-->[B<no>]B<auto>] [B<--tdsonly>=I<filespec> ...] [B<-->[B<no>]B<unixify>] [B<-->[B<no>]B<skip>] [B<--tdsdir>=I<dirname> ...] [B<--tex>=I<macro_pkg>] [B<-->[B<no>]B<miscify>] [B<-->[B<no>]B<tds>] I<filespec>[=I<dirname>] ... ctanify [B<--help>] ctanify [B<--version>] =head1 DESCRIPTION B<ctanify> is intended for developers who have a LaTeX package that they want to distribute via the Comprehensive TeX Archive Network (CTAN). Given a list of filenames, B<ctanify> creates a tarball (a F<.tar.gz> file) with the files laid out in CTAN's preferred structure. The tarball additionally contains a ZIP (F<.zip>) file with copies of all files laid out in the standard TeX Directory Structure (TDS), which facilitates inclusion of the package in the TeX Live distribution. =head1 OPTIONS B<ctanify> accepts the following command-line options: =over 5 =item B<-h>, B<--help> Output basic usage information and exit. =item B<-V>, B<--version> Output B<ctanify>'s version number and exit. =item B<-p> I<string>, B<--pkgname>=I<string> Specify explicitly a package name. Normally, B<ctanify> uses the base name of the first F<.ins> or F<.sty> file listed as the package name. The package name forms the base name of the tarball that B<ctanify> produces. =item B<--noauto> Do not automatically add files to the tarball. Normally, B<ctanify> automatically includes all files mentioned in a F<.ins> file. =item B<-t> I<filespec>, B<--tdsonly>=I<filespec> Specify a subset of the files named on the command line to include only in the TDS ZIP file, not in the CTAN package directory. Wildcards are allowed (quoted if necessary), and B<--tdsonly> can be used multiple times on the same command line. =back At least one filename must be specified on the command line. B<ctanify> automatically places files in the TDS tree based on their extension, but this can be overridden by specifying explicitly a target TDS directory using the form I<filespec>=I<dirname>. Wildcards are allowed for the filespec (quoted if necessary). =head1 ADDITIONAL OPTIONS The following options are unlikely to be necessary in ordinary usage. They are provided for special circumstances that may arise. =over 5 =item B<-d> I<dirname>, B<--tdsdir>=I<dirname> Instead of creating a tarball for CTAN, merely create the package TDS tree rooted in directory I<dirname>. =item B<-T> I<macro_pkg>, B<--tex>=I<macro_pkg> Assert that the files being packaged for CTAN target a TeX macro package other than LaTeX. Some common examples of I<macro_pkg> are C<generic>, C<plain>, and C<context>. =item B<-nou>, B<--no-unixify> Store text files unmodified instead of converting their end-of-line character to Unix format (a single linefeed character with no carriage-return character), even though CTAN prefers receiving all files with Unix-format end-of-line characters. =item B<-nok>, B<--no-skip> Force B<ctanify> to include files such as Unix hidden files, Emacs backup files, and version-control metadata files, all of which CTAN dislikes receiving. =item B<-m>, B<--miscify> Rename directories containing a single file to C<misc>. (For example, rename C<tex/latex/mypackage/mypackage.sty> to C<tex/latex/misc/mypackage.sty>.) This was common practice in the past but is now strongly discouraged. =item B<-nos>, B<--no-tds> Do not embed a .tds.zip file in the generated tarball. =back =head1 DIAGNOSTICS =over 5 =item C<Failed to copy I<filename> (No such file or directory)> This message is typically caused by a F<.ins> file that generates I<filename> but that has not already been run through F<tex> or F<latex> to actually produce I<filename>. B<ctanify> does not automatically run F<tex> or F<latex>; this needs to be done manually by the user. See L</CAVEATS> for more information. =item C<Modified I<filename> to use Unix line endings (use --no-unixify to prevent this)> For consistency, CTAN stores all text files with Unix-style line endings (a single linefeed character with no carriage-return character). To help in this effort, B<ctanify> automatically replaces non-Unix-style line endings. The preceding merely message notifies the user that he should not be alarmed to see a different size for I<filename> in the tarball versus the original I<filename> on disk (which B<ctanify> never modifies). If there's a good reason to preserve the original line endings (and there rarely is), the B<--no-unixify> option can be used to prevent B<ctanify> from altering any files when storing them in the tarball. =item C<Excluding I<filename> (use --no-skip to force inclusion)> B<ctanify> normally ignores files--even when specified explicitly on the command line--that CTAN prefers not receiving. These include files whose names start with "F<.>" (Unix hidden files), end in "F<~>" (Emacs automatic backups), or that come from a F<CVS> or F<.svn> directory (version-control metadata files). If there's a good reason to submit such files to CTAN (and there rarely is), the B<--no-skip> option can be used to prevent B<ctanify> from ignoring them. =item C<CTAN prefers having only PDF documentation (re: I<filename>)> Because of the popularity of the PDF format, CTAN wants to have as much documentation as possible distributed in PDF. The preceding message asks the user to replace any PostScript or DVI documentation with PDF if possible. (B<ctanify> will still include PostScript and DVI documentation in the tarball; the preceding message is merely a polite request.) =item C<Not including I<filename> in the TDS tree (unknown extension)> B<ctanify> places files in the TDS tree based on a table of file extensions. For example, all F<.sty> files are placed in F<tex/latex/I<package-name>>. If B<ctanify> does not know where to put a file it does not put it anywhere. See the last paragraph of L</OPTIONS> for an explanation of how to specify explicitly a file's target location in the TDS tree. For common file extensions that happen to be absent from B<ctanify>'s table, consider also notifying B<ctanify>'s author at the address shown below under L</AUTHOR>. =back =head1 EXAMPLES =head2 The Common Case Normally, all that's needed is to tell B<ctanify> the name of the F<.ins> file (or F<.sty> if the package does not use DocStrip) and the prebuilt documentation, if any: $ ctanify mypackage.ins mypackage.pdf README 490347 mypackage.tar.gz 1771 mypackage/README 15453 mypackage/mypackage.dtx 1957 mypackage/mypackage.ins 277683 mypackage/mypackage.pdf 246935 mypackage.tds.zip 1771 doc/latex/mypackage/README 277683 doc/latex/mypackage/mypackage.pdf 15453 source/latex/mypackage/mypackage.dtx 1957 source/latex/mypackage/mypackage.ins 1725 tex/latex/mypackage/mypackage.sty B<ctanify> outputs the size in bytes of the resulting tarball, each file within it, and each file within the contained ZIP file. In the preceding example, notice how B<ctanify> automatically performed all of the following operations: =over 5 =item * including F<mypackage.dtx> (found by parsing F<mypackage.ins>) in both the F<mypackage> directory and the ZIP file, =item * including F<mypackage.sty> (found by parsing F<mypackage.ins>) in the ZIP file but, because it's a generated file, not in the F<mypackage> directory, and =item * placing all files into appropriate TDS directories (documentation, source, main package) within the ZIP file. =back Consider what it would take to manually produce an equivalent F<mypackage.tar.gz> file. B<ctanify> is definitely a simpler, quicker alternative. =head2 Advanced Usage B<ctanify> assumes that PostScript files are documentation and therefore stores them under F<doc/latex/I<package-name>/> in the TDS tree within the ZIP File. Suppose, however, that a LaTeX package uses a set of PostScript files to control B<dvips>'s output. In this case, B<ctanify> must be told to include those PostScript files in the package directory, not the documentation directory. $ ctanify mypackage.ins "mypackage*.ps=tex/latex/mypackage" =head1 FILES =over 5 =item F<perl> B<ctanify> is written in Perl and needs a Perl installation to run. =item F<tar>, F<gzip> B<ctanify> requires the GNU F<tar> and F<gzip> programs to create a compressed tarball (F<.tar.gz>). =item F<zip> B<ctanify> uses a F<zip> program to archive the TDS tree within the main tarball. =back =head1 CAVEATS B<ctanify> does not invoke F<tex> or F<latex> on its own, S<e.g., to> process a F<.ins> file. The reason is that B<ctanify> does not know in the general case how to produce all of a package's generated files. It was deemed better to do nothing than to risk overwriting existing F<.sty> (or other) files or to include outdated generated files in the tarball. In short, before running B<ctanify> you should manually process any F<.ins> files and otherwise generate any files that should be sent to CTAN. B<ctanify> has been tested only on Linux. It may work on S<OS X>. I've been told that it works on Windows when run using Cygwin. Volunteers willing to help port B<ctanify> to other platforms are extremely welcome. =head1 SEE ALSO tar(1), zip(1), latex(1), Guidelines for uploading TDS-Packaged materials to CTAN (L<http://www.ctan.org/TDS-guidelines>), A Directory Structure for TeX Files (L<http://tug.org/tds/>), =head1 AUTHOR Scott Pakin, I<scott+ctify@pakin.org> =head1 COPYRIGHT AND LICENSE Copyright 2017 Scott Pakin This work may be distributed and/or modified under the conditions of the LaTeX Project Public License, either S<version 1.3c> of this license or (at your option) any later version. The latest version of this license is in =over 4 L<http://www.latex-project.org/lppl.txt> =back and S<version 1.3c> or later is part of all distributions of LaTeX version 2008/05/04 or later.