Module::ExtractUse(3) User Contributed Perl DocumentationModule::ExtractUse(3)NAMEModule::ExtractUse - Find out what modules are used
SYNOPSIS
use Module::ExtractUse;
# get a parser
my $p=Module::ExtractUse->new;
# parse from a file
$p->extract_use('/path/to/module.pm');
# or parse from a ref to a string in memory
$p->extract_use(\$string_containg_code);
# use some reporting methods
my $used=$p->used; # $used is a HASHREF
print $p->used('strict') # true if code includes 'use strict'
my @used=$p->array;
my $used=$p->string;
DESCRIPTIONModule::ExtractUse is basically a Parse::RecDescent grammar to parse
Perl code. It tries very hard to find all modules (whether pragmas,
Core, or from CPAN) used by the parsed code.
"Usage" is defined by either calling "use" or "require".
Methods
new
my $p=Module::ExtractUse->new;
Returns a parser object
extract_use
$p->extract_use('/path/to/module.pm');
$p->extract_use(\$string_containg_code);
Runs the parser.
$code_to_parse can be either a SCALAR, in which case Module::ExtractUse
tries to open the file specified in $code_to_parse. Or a reference to a
SCALAR, in which case Module::ExtractUse assumes the referenced scalar
contains the source code.
The code will be stripped from POD (using Pod::Strip) and splitted on
";" (semicolon). Each statement (i.e. the stuff between two semicolons)
is checked by a simple regular expression.
If the statement contains either 'use' or 'require', the statment is
handed over to the parser, who then tries to figure out, what is used
or required. The results will be saved in a data structure that you can
examine afterwards.
You can call "extract_use" several times on different files. It will
count how many files where examined and how often each module was used.
Accessor Methods
Those are various ways to get at the result of the parse.
Note that "extract_use" returns the parser object, so you can say
print $p->extract_use($code_to_parse)->string;
used
my $used=$p->used; # $used is a HASHREF
print $p->used('strict') # true if code includes 'use strict'
If called without an argument, returns a reference to an hash of all
used modules. Keys are the names of the modules, values are the number
of times they were used.
If called with an argument, looks up the value of the argument in the
hash and returns the number of times it was found during parsing.
This is the prefered accessor.
string
print $p->string($seperator)
Returns a sorted string of all used modules, joined using the value of
$seperator or using a blank space as a default;
Module names are sorted by ascii value (i.e by "sort")
array
my @array = $p->array;
Returns an array of all used modules.
arrayref
my $arrayref = $p->arrayref;
Returns a reference to an array of all used modules. Surprise!
files
Returns the number of files parsed by the parser object.
RE-COMPILING THE GRAMMAR
If - for some reasons - you need to alter the grammar, edit the file
grammar and afterwards run:
perl -MParse::RecDescent - grammar Module::ExtractUse::Grammar
Make sure you're in the right directory, i.e. in .../Module/ExtractUse/
EXPORTS
Nothing.
SEE ALSO
Parse::RecDescent, Module::ScanDeps, Module::Info,
Module::CPANTS::Analyse
AUTHOR
Thomas Klausner <domm@zsi.at>
BUGS
Please report any bugs or feature requests to
"bug-module-extractuse@rt.cpan.org", or through the web interface at
<http://rt.cpan.org>. I will be notified, and then you'll
automatically be notified of progress on your bug as I make changes.
LICENSEModule::ExtractUse is Copyright (c) 2003-2008, Thomas Klausner.
You may use and distribute this module according to the same terms that
Perl is distributed under.
perl v5.14.1 2011-06-20 Module::ExtractUse(3)
