Help-Site Computer Manuals
  Algorithms & Data Structures   Programming Languages   Revision Control
  Cameras   Computers   Displays   Keyboards & Mice   Motherboards   Networking   Printers & Scanners   Storage
  Windows   Linux & Unix   Mac
Utility to generate UML class diagrams from Perl source or runtime - Utility to generate UML class diagrams from Perl source or runtime

NAME - Utility to generate UML class diagrams from Perl source or runtime


    $ -M Foo -o foo.png -p "^Foo::"

    $ -o bar.gif -p "Bar::|Baz::" lib/ lib/*/*.pm

    $ -o blah.png -p Blah -r ./blib


This is a simple command-line frontend for the the UML::Class::Simple manpage module.

I'll illustrate the usage of this tool via some real-world examples.

Draw Stevan's Moose

  $ -M Moose -o samples/moose_small.png -p "^(Class::MOP|Moose::)" -s 4x8

This command will generate a simple class diagram in PNG format for the Moose module with classes having names matching the regex "^(Class::MOP|Moose::)". The image's width is 4 inches while its height is 8 inches.

We need the -M option here since needs to preload Moose into the memory so as to inspect it at runtime.

The graphical output is given below:

(See also

Yes, the image above looks very fuzzy since the whole stuff is huge. If you strip the -s option, then the resulting image will enlarge automatically:

  $ -M Moose -o samples/moose_big.png -p "^(Class::MOP|Moose::)"

The image obtained is really really large, I won't show it here, but you can browse it in your favorite picture browser from

Before trying out these commands yourself, please make sure that you have Moose already installed. (It's also on CPAN, btw.)

Draw Alias's PPI

  $ -M PPI -o samples/ppi_small.png -p "^PPI::" -s 10x10

(See also

Or the full-size version:

  $ -M PPI -o samples/ppi_big.png -p "^PPI::"


BTW, PPI is a prerequisite of this module.

Draw from UML::Class::Simple's Test Suite

  $ -M FAST -o samples/fast.png -s 5x10 -r t/FAST/lib

This is an example of drawing classes contained in Perl source files.

Draw Modules of Your Own

Suppose that you're a CPAN author too and want to produce a class diagram for all the classes contained in your lib/ directory. The following command can do all the hard work for you:

    $ -o mylib.png -r lib

or just plot the packages in the specified .pm files:

    $ -o a.png lib/ lib/bar/

or even specify a pattern (in perl regex) to filter out the packages you want to draw:

    $ -o a.png -p "^Foo::" lib/

Quite handy, isn't it? ;-)


Never feed plain module names to, for intance,

  $ Scalar::Defer  # DO NOT DO THIS!

will lead you to the following error message:

  error: input file Scalar::Defer not found.

Use -M and -p options to achieve your goals:

  $ -M Scalar::Defer -p "Scalar::Defer"

In this example, I must warn you that you may miss the packages which belong to Scalar::Defer but don't have ``Scalar::Defer'' in their names. I'm sorry for that. is not that smart.

The safest ways to do this are

  1. Don't specify the -p regex option and generate a large image which shows every classes including CORE modules, figure out the appropriate class name pattern yourself, and rerun with the right regex pattern.

  2. Grab the Scalar::Defer's tarball, and do something like this:
       $ -r Scalar-Defer-0.07/lib

It's worth mentioning that when .pl or .pm files are passing as the command line arguments, only the classes defined in these files will be drawn. This is a feature. :)

For .pm files on your disk, simply pass them as the command line arguments. For instance:

   $ -o bar.gif lib/ lib/*/*.pm

or tell to iterate through the directories for you:

   $ -o blah.png -r ./lib


--color color
-c color
Sets the node color. Defaults to #f1e1f4.

You can either specify RGB values like #rrggbb in hex form, or color names like ``grey'' and ``red''.

--exclude path
-E path
excludes modules that were installed to path from the drawing. multiple -E options are supported.

Shows the help message.

--include path
-I path
Draws only the classes that were installed to path in the drawing. multiple -I options are supported.

-M module
Preloads the module which contains the classes you want to depict. For example,

    $ -M PPI -o ppi.png -p "^PPI::"

Multiple -M options are accepted. For instance:

    $ -M Foo -M Bar::Baz -p "Class::"

--out outfile
-o outfile
Specifies the output file name. Note that the file extension will be honored. If you specify ``-o foo.png'', a PNG image named foo.png will be generated, and if you specify ``-o'', the dot source file named will be obtained. Likewise, ``-o foo.yml'' will lead to a YAML file holding the whole internal DOM data.

A typical usage is as follows:

    $ -o foo.yml lib/

    # ...edit the foo.yml so as to adjust the class info

    # feed the updated back

    $ -o foo.yml

    # ...edit the so as to adjust the graphviz dot source

    # now feed the updated back

    $ -o foo.png

You see, allows you to control the behaviors at several different levels. I really like this freedom, since tools can't always do exactly what I want.

If no -o option was specified, a.png will be assumed.

--pattern regex
-p regex
Specifies the pattern (perl regex) used to filter out the class names to be drawn.

Shows public methods only.

Processes subdirectories of input directories recursively.

-s <w>x<h>
Specifies the width and height of the resulting image. For example:

    -s 3.6x7

    --size 5x6

where the unit is inches instead of pixels.


  • If the user passes plain module names like ``Foo::Bar'', then its (and only its) ancestors and subclasses will be drawn. (This is suggested by Christopher Malon.)


Agent Zhang <>


Copyright 2006 by Agent Zhang. All rights reserved.

This library is free software; you can redistribute it and/or modify it under the same terms as perl itself.


the UML::Class::Simple manpage.