Perltidy can save you a lot of tedious editing if you spend a few
minutes learning to use it effectively. Perltidy is highly
configurable, but for many programmers the default parameter set will be
satisfactory, with perhaps a few additional parameters to account for
style preferences.

This tutorial assumes that perltidy has been installed on your system.
Installation instructions accompany the package. To follow along with
this tutorial, please find a small Perl script and place a copy in a
temporary directory. For example, here is a small (and silly) script:

Assume that the name of your script is testfile.pl. You can reformat it
with the default options to use the style recommended in the perlstyle man
pages with the command:

perltidy testfile.pl

For safety, perltidy never overwrites your original file. In this case,
its output will go to a file named testfile.pl.tdy, which you should
examine now with your editor. Here is what the above file looks like
with the default options:

You'll notice an immediate style change from the ``cuddled-else'' style of
the original to the default ``non-cuddled-else'' style. This is because
perltidy has to make some kind of default selection of formatting
options, and this default tries to follow the suggestions in the
perlstyle man pages.

If you prefer the original ``cuddled-else'' style, don't worry, you can
indicate that with a -ce flag. So if you rerun with that flag

perltidy -ce testfile.pl

you will see a return to the original ``cuddled-else'' style. There are
many more parameters for controlling style, and some of the most useful
of these are discussed below.

Another noticeable difference between the original and the reformatted
file is that the indentation has been changed from 2 spaces to 4 spaces.
That's because 4 spaces is the default. You may change this to be a
different number with -i=n.

To get some practice, try these examples, and examine the resulting
testfile.pl.tdy file:

perltidy -i=8 testfile.pl

This changes the default of 4 spaces per indentation level to be 8. Now
just to emphasize the point, try this and examine the result:

This is a good place to mention a few points regarding the input flags.
First, for each option, there are two forms, a long form and a short
form, and either may be used.

For example, if you want to change the number of columns corresponding to one
indentation level to 3 (from the default of 4) you may use either

-i=3 or --indent-columns=3

The short forms are convenient for entering parameters by hand, whereas
the long forms, though often ridiculously long, are self-documenting and
therefore useful in configuration scripts. You may use either one or
two dashes ahead of the parameters. Also, the '=' sign is optional,
and may be a single space instead. However, the value of a parameter
must NOT be adjacent to the flag, like this -i3 (WRONG). Also,
flags must be input separately, never bundled together.

If you change the indentation spaces you will probably also need to
change the continuation indentation spaces with the parameter -ci=n.
The continuation indentation is the extra indentation -- 2 spaces by
default -- given to that portion of a long line which has been placed
below the start of a statement. For example:

There is no fixed rule for setting the value for -ci=n, but it should
probably not exceed one-half of the number of spaces of a full
indentation level.

In the above snippet, the statement was broken into three lines. The
actual number is governed by a parameter, the maximum line length, as
well as by what perltidy considers to be good break points. The maximum
line length is 80 characters by default. You can change this to be any
number n with the -l=n flag. Perltidy tries to produce lines
which do not exceed this length, and it does this by finding good break
points. For example, the above snippet would look like this with
perltidy -l=40:

With indentation, there is always a tab issue to resolve. By default,
perltidy will use leading ascii space characters instead of tabs. The
reason is that this will be displayed correctly by virtually all
editors, and in the long run, will avoid maintenance problems.

However, if you prefer, you may have perltidy entab the leading
whitespace of a line with the command -et=n, where n is the number
of spaces which will be represented by one tab. But note that your text
will not be displayed properly unless viewed with software that is
configured to display n spaces per tab.

In the first example, we saw that if we pass perltidy the name
of a file on the command line, it reformats it and creates a
new filename by appending an extension, .tdy. This is the
default behavior, but there are several other options.

On most systems, you may use wildcards to reformat a whole batch of
files at once, like this for example:

perltidy *.pl

and in this case, each of the output files will be have a name equal to
the input file with the extension .tdy appended. If you decide that
the formatting is acceptable, you will want to backup your originals and
then remove the .tdy extensions from the reformatted files. There is
an powerful perl script called rename that can be used for this
purpose; if you don't have it, you can find it for example in The Perl
Cookbook.

If you find that the formatting done by perltidy is usually acceptable,
you may want to save some effort by letting perltidy do a simple backup
of the original files and then reformat them in place. You specify this
with a -b flag. For example, the command

perltidy -b *.pl

will rename the original files by appending a .bak extension, and then
create reformatted files with the same names as the originals. (If you don't
like the default backup extension choice .bak, the manual tells how to
change it). Each time you run perltidy with the -b option, the previous
.bak files will be overwritten, so please make regular separate backups.

If there is no input filename specified on the command line, then input
is assumed to come from standard input and output will go to standard
output. On systems with a Unix-like interface, you can use perltidy as
a filter, like this:

perltidy <somefile.pl >newfile.pl

What happens in this case is that the shell takes care of the redirected
input files, '<somefile.pl', and so perltidy never sees the filename.
Therefore, it knows to use the standard input and standard output
channels.

If you are executing perltidy on a file and want to force the output
to standard output, rather than create a .tdy file, you can
indicate this with the flag -st, like this:

perltidy somefile.pl -st >otherfile.pl

You can also control the name of the output file with the -o flag,
like this:

Perltidy has to make some kind of default selection of formatting
options, and its choice is to try to follow the suggestions in the
perlstyle man pages. Many programmers more or less follow these
suggestions with a few exceptions. In this section we will
look at just a few of the most commonly used style parameters. Later,
you may want to systematically develop a set of style
parameters with the help of
the perltidy stylekey web page at
http://perltidy.sourceforge.net/stylekey.html

which is preferred by some. (I've actually used -lp and -cti=1 to
format this block. The -cti=1 flag causes the closing paren to align
vertically with the opening paren, which works well with the -lp
indentation style). An advantage of -lp indentation are that it
displays lists nicely. A disadvantage is that deeply nested lists can
require a long line length.

These are parameters for controlling the amount of space within
containing parentheses, braces, and square brackets. The example below
shows the effect of the three possible values, 0, 1, and 2, for the case
of parentheses:

A value of 0 causes all parens to be padded on the inside with a space,
and a value of 2 causes this never to happen. With a value of 1, spaces
will be introduced if the item within is more than a single token.

While style preferences vary, most people would agree that it is
important to maintain a uniform style within a script, and this is a
major benefit provided by perltidy. Once you have decided on which, if
any, special options you prefer, you may want to avoid having to enter
them each time you run it. You can do this by creating a special file
named .perltidyrc in either your home directory, your current
directory, or certain system-dependent locations. (Note the leading ``.''
in the file name).

A handy command to know when you start using a configuration file is

perltidy -dpro

which will dump to standard output the search that perltidy makes when
looking for a configuration file, and the contents of the one that it
selects, if any. This is one of a number of useful ``dump and die''
commands, in which perltidy will dump some information to standard
output and then immediately exit. Others include -h, which dumps
help information, and -v, which dumps the version number.

Another useful command when working with configuration files is

perltidy -pro=file

which causes the contents of file to be used as the configuration
file instead of a .perltidyrc file. With this command, you can
easily switch among several different candidate configuration files
during testing.

This .perltidyrc file is free format. It is simply a list of
parameters, just as they would be entered on a command line. Any number
of lines may be used, with any number of parameters per line, although
it may be easiest to read with one parameter per line. Blank lines are
ignored, and text after a '#' is ignored to the end of a line.

Here is an example of a .perltidyrc file:

# This is a simple of a .perltidyrc configuration file
# This implements a highly spaced style
-bl # braces on new lines
-pt=0 # parens not tight at all
-bt=0 # braces not tight
-sbt=0 # square brackets not tight

If you experiment with this file, remember that it is in your directory,
since if you are running on a Unix system, files beginning with a ``.''
are normally hidden.

If you have a .perltidyrc file, and want perltidy to ignore it,
use the -npro flag on the command line.

Let's run through a 'fire drill' to see how perltidy reports errors. Try
introducing an extra opening brace somewhere in a test file. For example,
introducing an extra brace in the file listed above produces the following
message on the terminal (or standard error output):

## Please see file testfile.pl.ERR!

Here is what testfile.pl.ERR contains:

10: final indentation level: 1
Final nesting depth of '{'s is 1
The most recent un-matched '{' is on line 6
6: } elsif ($temperature < 68) {{
^

This shows how perltidy will, by default, write error messages to a file
with the extension .ERR, and it will write a note that it did so to
the standard error device. If you would prefer to have the error
messages sent to standard output, instead of to a .ERR file, use the
-se flag.

Almost every programmer would want to see error messages of this type,
but there are a number of messages which, if reported, would be
annoying. To manage this problem, perltidy puts its messages into two
categories: errors and warnings. The default is to just report the
errors, but you can control this with input flags, as follows:

flag what this does
---- --------------
default: report errors but not warnings
-w report all errors and warnings
-q quiet! do not report either errors or warnings

The default is generally a good choice, but it's not a bad idea to check
programs with -w occasionally, especially if your are looking for a
bug. For example, it will ask if you really want '=' instead of '=~' in
this line:

One last topic that needs to be touched upon concerns the .LOG file.
This is where perltidy records messages that are not normally of any
interest, but which just might occasionally be useful. This file is not
saved, though, unless perltidy detects that it has made a mistake or you
ask for it to be saved.

There are a couple of ways to ask perltidy to save a log file. To
create a relatively sparse log file, use

perltidy -log testfile.pl

and for a verbose log file, use

perltidy -g testfile.pl

The difference is that the first form only saves detailed information at
least every 50th line, while the second form saves detailed information
about every line.

So returning to our example, lets force perltidy to save a
verbose log file by issuing the following command

perltidy -g testfile.pl

You will find that a file named testfile.pl.LOG has been
created in your directory.

If you open this file, you will see that it is a text file with a
combination of warning messages and informative messages. All you need
to know for now is that it exists; someday it may be useful.

Most programmer's editors allow a selected group of lines to be passed
through an external filter. Perltidy has been designed to work well as
a filter, and it is well worthwhile learning the appropriate commands to
do this with your editor. This means that you can enter a few
keystrokes and watch a block of text get reformatted. If you are not
doing this, you are missing out of a lot of fun! You may want to supply
the -q flag to prevent error messages regarding incorrect syntax,
since errors may be obvious in the indentation of the reformatted text.
This is entirely optional, but if you do not use the -q flag, you
will need to use the undo keys in case an error message appears on the
screen.

For example, within the vim editor it is only necessary to select the
text by any of the text selection methods, and then issue the command
!perltidy in command mode. Thus, an entire file can be formatted using

:%!perltidy -q

or, without the -q flag, just

:%!perltidy

It isn't necessary to format an entire file, however. Perltidy will
probably work well as long as you select blocks of text whose braces,
parentheses, and square brackets are properly balanced. You can
even format an elsif block without the leading if block, as
long as the text you select has all braces balanced.

For the emacs editor, first mark a region and then pipe it through
perltidy. For example, to format an entire file, select it with C-x h
and then pipe it with M-1 M-| and then perltidy. The numeric
argument, M-1 causes the output from perltidy to replace the marked
text. See ``GNU Emacs Manual'' for more information,
http://www.gnu.org/manual/emacs-20.3/html_node/emacs_toc.html

If you have difficulty with an editor, try the -st flag, which will
force perltidy to send output to standard output. This might be needed,
for example, if the editor passes text to perltidy as temporary filename
instead of through the standard input. If this works, you might put the
-st flag in your .perltidyrc file.

If you have some tips for making perltidy work with your editor, and
are willing to share them, please email me (see below) and I'll try to
incorporate them in this document or put up a link to them.

After you get your editor and perltidy successfully talking to each
other, try formatting a snippet of code with a brace error to see what
happens. (Do not use the quiet flag, -q, for this test). Perltidy
will send one line starting with ## to standard error output. Your
editor may either display it at the top of the reformatted text or at
the bottom (or even midstream!). You probably cannot control this, and
perltidy can't, but you need to know where to look when an actual error
is detected.

Perltidy can switch between two different output modes. We have been
discussing what might be called its ``beautifier'' mode, but it can also
output in HTML. To do this, use the -html flag, like this:

perltidy -html testfile.pl

which will produce a file testfile.pl.html. There are many
parameters available for adjusting the appearance of an HTML file, but a
very easy way is to just write the HTML file with this simple command
and then edit the stylesheet which is embedded at its top.

One important thing to know about the -html flag is that perltidy can
either send its output to its beautifier or to its HTML writer, but
(unfortunately) not both in a single run. So the situation can be
represented like this: