1PPI(3) User Contributed Perl Documentation PPI(3)
2
6 PPI - Parse, Analyze and Manipulate Perl (without perl)
7
9 use PPI;
10 # Create a new empty document
12 my $Document = PPI::Document->new;
13 # Create a document from source
15 $Document = PPI::Document->new(\'print "Hello World!\n"');
16 # Load a Document from a file
18 $Document = PPI::Document->new('Module.pm');
19 # Does it contain any POD?
21 if ( $Document->find_any('PPI::Token::Pod') ) {
22 print "Module contains POD\n";
23 }
24 # Get the name of the main package
26 $pkg = $Document->find_first('PPI::Statement::Package')->namespace;
27 # Remove all that nasty documentation
29 $Document->prune('PPI::Token::Pod');
30 $Document->prune('PPI::Token::Comment');
31 # Save the file
33 $Document->save('Module.pm.stripped');
34
36 About this Document
37 This is the PPI manual. It describes its reason for existing, its
38 general structure, its use, an overview of the API, and provides a few
39 implementation samples.
40 Background
42 The ability to read, and manipulate Perl (the language)
43 programmatically other than with perl (the application) was one that
44 caused difficulty for a long time.
45 The cause of this problem was Perl's complex and dynamic grammar.
47 Although there is typically not a huge diversity in the grammar of most
48 Perl code, certain issues cause large problems when it comes to
49 parsing.
50 Indeed, quite early in Perl's history Tom Christenson introduced the
52 Perl community to the quote "Nothing but perl can parse Perl", or as it
53 is more often stated now as a truism:
54 "Only perl can parse Perl"
56 One example of the sorts of things the prevent Perl being easily parsed
58 are function signatures, as demonstrated by the following.
59 @result = (dothis $foo, $bar);
61 # Which of the following is it equivalent to?
63 @result = (dothis($foo), $bar);
64 @result = dothis($foo, $bar);
65 The first line above can be interpreted in two different ways,
67 depending on whether the &dothis function is expecting one argument, or
68 two, or several.
69 A "code parser" (something that parses for the purpose of execution)
71 such as perl needs information that is not found in the immediate
72 vicinity of the statement being parsed.
73 The information might not just be elsewhere in the file, it might not
75 even be in the same file at all. It might also not be able to determine
76 this information without the prior execution of a "BEGIN {}" block, or
77 the loading and execution of one or more external modules. Or worse the
78 &dothis function may not even have been written yet.
79 When parsing Perl as code, you must also execute it
81 Even perl itself never really fully understands the structure of the
83 source code after and indeed as it processes it, and in that sense
84 doesn't "parse" Perl source into anything remotely like a structured
85 document. This makes it of no real use for any task that needs to
86 treat the source code as a document, and do so reliably and robustly.
87 For more information on why it is impossible to parse perl, see Randal
89 Schwartz's seminal response to the question of "Why can't you parse
90 Perl".
91 <http://www.perlmonks.org/index.pl?node_id=44722>
93 The purpose of PPI is not to parse Perl Code, but to parse Perl
95 Documents. By treating the problem this way, we are able to parse a
96 single file containing Perl source code "isolated" from any other
97 resources, such as libraries upon which the code may depend, and
98 without needing to run an instance of perl alongside or inside the
99 parser.
100 Historically, using an embedded perl parser was widely considered to be
102 the most likely avenue for finding a solution to "Parse::Perl". It was
103 investigated from time to time and attempts have generally failed or
104 suffered from sufficiently bad corner cases that they were abandoned.
105 What Does PPI Stand For?
107 "PPI" is an acronym for the longer original module name
108 "Parse::Perl::Isolated". And in the spirit or the silly acronym games
109 played by certain unnamed Open Source projects you may have hurd of, it
110 also a reverse backronym of "I Parse Perl".
111 Of course, I could just be lying and have just made that second bit up
113 10 minutes before the release of PPI 1.000. Besides, all the cool Perl
114 packages have TLAs (Three Letter Acronyms). It's a rule or something.
115 Why don't you just think of it as the Perl Parsing Interface for
117 simplicity.
118 The original name was shortened to prevent the author (and you the
120 users) from contracting RSI by having to type crazy things like
121 "Parse::Perl::Isolated::Token::QuoteLike::Backtick" 100 times a day.
122 In acknowledgment that someone may some day come up with a valid
124 solution for the grammar problem it was decided at the commencement of
125 the project to leave the "Parse::Perl" namespace free for any such
126 effort.
127 Since that time I've been able to prove to my own satisfaction that it
129 is truly impossible to accurately parse Perl as both code and document
130 at once. For the academics, parsing Perl suffers from the "Halting
131 Problem".
132 With this in mind "Parse::Perl" has now been co-opted as the title for
134 the SourceForge project that publishes PPI and a large collection of
135 other applications and modules related to the (document) parsing of
136 Perl source code.
137 You can find this project at <http://sf.net/projects/parseperl>,
139 however we no longer use the SourceForge CVS server. Instead, the
140 current development version of PPI is available via SVN at
141 <http://svn.ali.as/cpan/trunk/PPI/>.
142 Why Parse Perl?
144 Once you can accept that we will never be able to parse Perl well
145 enough to meet the standards of things that treat Perl as code, it is
146 worth re-examining "why" we want to "parse" Perl at all.
147 What are the things that people might want a "Perl parser" for.
149 Documentation
151 Analyzing the contents of a Perl document to automatically generate
152 documentation, in parallel to, or as a replacement for, POD
153 documentation.
154 Allow an indexer to to locate and process all the comments and
156 documentation from code for "full text search" applications.
157 Structural and Quality Analysis
159 Determine quality or other metrics across a body of code, and
160 identify situations relating to particular phrases, techniques or
161 locations.
162 Index functions, variables and packages within Perl code, and doing
164 search and graph (in the node/edge sense) analysis of large code
165 bases.
166 Refactoring
168 Make structural, syntax, or other changes to code in an automated
169 manner, either independently or in assistance to an editor. This
170 sort of task list includes backporting, forward porting, partial
171 evaluation, "improving" code, or whatever. All the sort of things
172 you'd want from a Perl::Editor.
173 Layout
175 Change the layout of code without changing its meaning. This
176 includes techniques such as tidying (like perltidy), obfuscation,
177 compressing and "squishing", or to implement formatting preferences
178 or policies.
179 Presentation
181 This includes methods of improving the presentation of code,
182 without changing the content of the code. Modify, improve, syntax
183 colour etc the presentation of a Perl document. Generating
184 "IntelliText"-like functions.
185 If we treat this as a baseline for the sort of things we are going to
187 have to build on top of Perl, then it becomes possible to identify a
188 standard for how good a Perl parser needs to be.
189 How good is Good Enough(TM)
191 PPI seeks to be good enough to achieve all of the above tasks, or to
192 provide a sufficiently good API on which to allow others to implement
193 modules in these and related areas.
194 However, there are going to be limits to this process. Because PPI
196 cannot adapt to changing grammars, any code written using source
197 filters should not be assumed to be parsable.
198 At one extreme, this includes anything munged by Acme::Bleach, as well
200 as (arguably) more common cases like Switch. We do not pretend to be
201 able to always parse code using these modules, although as long as it
202 still follows a format that looks like Perl syntax, it may be possible
203 to extend the lexer to handle them.
204 The ability to extend PPI to handle lexical additions to the language
206 is on the drawing board to be done some time post-1.0
207 The goal for success was originally to be able to successfully parse
209 99% of all Perl documents contained in CPAN. This means the entire file
210 in each case.
211 PPI has succeeded in this goal far beyond the expectations of even the
213 author. At time of writing there are only 28 non-Acme Perl modules in
214 CPAN that PPI is incapable of parsing. Most of these are so badly
215 broken they do not compile as Perl code anyway.
216 So unless you are actively going out of your way to break PPI, you
218 should expect that it will handle your code just fine.
219 Internationalisation
221 PPI provides partial support for internationalisation and localisation.
222 Specifically, it allows the use characters from the Latin-1 character
224 set to be used in quotes, comments, and POD. Primarily, this covers
225 languages from Europe and South America.
226 PPI does not currently provide support for Unicode, although there is
228 an initial implementation available in a development branch from CVS.
229 If you need Unicode support, and would like to help stress test the
231 Unicode support so we can move it to the main branch and enable it in
232 the main release should contact the author. (contact details below)
233 Round Trip Safe
235 When PPI parses a file it builds everything into the model, including
236 whitespace. This is needed in order to make the Document fully "Round
237 Trip" safe.
238 The general concept behind a "Round Trip" parser is that it knows what
240 it is parsing is somewhat uncertain, and so expects to get things wrong
241 from time to time. In the cases where it parses code wrongly the tree
242 will serialize back out to the same string of code that was read in,
243 repairing the parser's mistake as it heads back out to the file.
244 The end result is that if you parse in a file and serialize it back out
246 without changing the tree, you are guaranteed to get the same file you
247 started with. PPI does this correctly and reliably for 100% of all
248 known cases.
249 What goes in, will come out. Every time.
251 The one minor exception at this time is that if the newlines for your
253 file are wrong (meaning not matching the platform newline format), PPI
254 will localise them for you. (It isn't to be convenient, supporting
255 arbitrary newlines would make some of the code more complicated)
256 Better control of the newline type is on the wish list though, and
258 anyone wanting to help out is encouraged to contact the author.
259
261 General Layout
262 PPI is built upon two primary "parsing" components, PPI::Tokenizer and
263 PPI::Lexer, and a large tree of about 50 classes which implement the
264 various the Perl Document Object Model (PDOM).
265 The PDOM is conceptually similar in style and intent to the regular DOM
267 or other code Abstract Syntax Trees (ASTs), but contains some
268 differences to handle perl-specific cases, and to assist in treating
269 the code as a document. Please note that it is not an implementation of
270 the official Document Object Model specification, only somewhat similar
271 to it.
272 On top of the Tokenizer, Lexer and the classes of the PDOM, sit a
274 number of classes intended to make life a little easier when dealing
275 with PDOM trees.
276 Both the major parsing components were hand-coded from scratch with
278 only plain Perl code and a few small utility modules. There are no
279 grammar or patterns mini-languages, no YACC or LEX style tools and only
280 a small number of regular expressions.
281 This is primarily because of the sheer volume of accumulated cruft that
283 exists in Perl. Not even perl itself is capable of parsing Perl
284 documents (remember, it just parses and executes it as code).
285 As a result, PPI needed to be cruftier than perl itself. Feel free to
287 shudder at this point, and hope you never have to understand the
288 Tokenizer codebase. Speaking of which...
289 The Tokenizer
291 The Tokenizer takes source code and converts it into a series of
292 tokens. It does this using a slow but thorough character by character
293 manual process, rather than using a pattern system or complex regexes.
294 Or at least it does so conceptually. If you were to actually trace the
296 code you would find it's not truly character by character due to a
297 number of regexps and optimisations throughout the code. This lets the
298 Tokenizer "skip ahead" when it can find shortcuts, so it tends to jump
299 around a line a bit wildly at times.
300 In practice, the number of times the Tokenizer will actually move the
302 character cursor itself is only about 5% - 10% higher than the number
303 of tokens contained in the file. This makes it about as optimal as it
304 can be made without implementing it in something other than Perl.
305 In 2001 when PPI was started, this structure made PPI quite slow, and
307 not really suitable for interactive tasks. This situation has improved
308 greatly with multi-gigahertz processors, but can still be painful when
309 working with very large files.
310 The target parsing rate for PPI is about 5000 lines per gigacycle. It
312 is currently believed to be at about 1500, and main avenue for making
313 it to the target speed has now become PPI::XS, a drop-in XS accelerator
314 for PPI.
315 Since PPI::XS has only just gotten off the ground and is currently only
317 at proof-of-concept stage, this may take a little while. Anyone
318 interested in helping out with PPI::XS is highly encouraged to contact
319 the author. In fact, the design of PPI::XS means it's possible to port
320 one function at a time safely and reliably. So every little bit will
321 help.
322 The Lexer
324 The Lexer takes a token stream, and converts it to a lexical tree.
325 Because we are parsing Perl documents this includes whitespace,
326 comments, and all number of weird things that have no relevance when
327 code is actually executed.
328 An instantiated PPI::Lexer consumes PPI::Tokenizer objects and produces
330 PPI::Document objects. However you should probably never be working
331 with the Lexer directly. You should just be able to create
332 PPI::Document objects and work with them directly.
333 The Perl Document Object Model
335 The PDOM is a structured collection of data classes that together
336 provide a correct and scalable model for documents that follow the
337 standard Perl syntax.
338 The PDOM Class Tree
340 The following lists all of the 67 current PDOM classes, listing with
341 indentation based on inheritance.
342 PPI::Element
344 PPI::Node
345 PPI::Document
346 PPI::Document::Fragment
347 PPI::Statement
348 PPI::Statement::Package
349 PPI::Statement::Include
350 PPI::Statement::Sub
351 PPI::Statement::Scheduled
352 PPI::Statement::Compound
353 PPI::Statement::Break
354 PPI::Statement::Given
355 PPI::Statement::When
356 PPI::Statement::Data
357 PPI::Statement::End
358 PPI::Statement::Expression
359 PPI::Statement::Variable
360 PPI::Statement::Null
361 PPI::Statement::UnmatchedBrace
362 PPI::Statement::Unknown
363 PPI::Structure
364 PPI::Structure::Block
365 PPI::Structure::Subscript
366 PPI::Structure::Constructor
367 PPI::Structure::Condition
368 PPI::Structure::List
369 PPI::Structure::For
370 PPI::Structure::Given
371 PPI::Structure::When
372 PPI::Structure::Unknown
373 PPI::Token
374 PPI::Token::Whitespace
375 PPI::Token::Comment
376 PPI::Token::Pod
377 PPI::Token::Number
378 PPI::Token::Number::Binary
379 PPI::Token::Number::Octal
380 PPI::Token::Number::Hex
381 PPI::Token::Number::Float
382 PPI::Token::Number::Exp
383 PPI::Token::Number::Version
384 PPI::Token::Word
385 PPI::Token::DashedWord
386 PPI::Token::Symbol
387 PPI::Token::Magic
388 PPI::Token::ArrayIndex
389 PPI::Token::Operator
390 PPI::Token::Quote
391 PPI::Token::Quote::Single
392 PPI::Token::Quote::Double
393 PPI::Token::Quote::Literal
394 PPI::Token::Quote::Interpolate
395 PPI::Token::QuoteLike
396 PPI::Token::QuoteLike::Backtick
397 PPI::Token::QuoteLike::Command
398 PPI::Token::QuoteLike::Regexp
399 PPI::Token::QuoteLike::Words
400 PPI::Token::QuoteLike::Readline
401 PPI::Token::Regexp
402 PPI::Token::Regexp::Match
403 PPI::Token::Regexp::Substitute
404 PPI::Token::Regexp::Transliterate
405 PPI::Token::HereDoc
406 PPI::Token::Cast
407 PPI::Token::Structure
408 PPI::Token::Label
409 PPI::Token::Separator
410 PPI::Token::Data
411 PPI::Token::End
412 PPI::Token::Prototype
413 PPI::Token::Attribute
414 PPI::Token::Unknown
415 To summarize the above layout, all PDOM objects inherit from the
417 PPI::Element class.
418 Under this are PPI::Token, strings of content with a known type, and
420 PPI::Node, syntactically significant containers that hold other
421 Elements.
422 The three most important of these are the PPI::Document, the
424 PPI::Statement and the PPI::Structure classes.
425 The Document, Statement and Structure
427 At the top of all complete PDOM trees is a PPI::Document object. It
428 represents a complete file of Perl source code as you might find it on
429 disk.
430 There are some specialised types of document, such as
432 PPI::Document::File and PPI::Document::Normalized but for the purposes
433 of the PDOM they are all just considered to be the same thing.
434 Each Document will contain a number of Statements, Structures and
436 Tokens.
437 A PPI::Statement is any series of Tokens and Structures that are
439 treated as a single contiguous statement by perl itself. You should
440 note that a Statement is as close as PPI can get to "parsing" the code
441 in the sense that perl-itself parses Perl code when it is building the
442 op-tree.
443 Because of the isolation and Perl's syntax, it is provably impossible
445 for PPI to accurately determine precedence of operators or which tokens
446 are implicit arguments to a sub call.
447 So rather than lead you on with a bad guess that has a strong chance of
449 being wrong, PPI does not attempt to determine precedence or sub
450 parameters at all.
451 At a fundamental level, it only knows that this series of elements
453 represents a single Statement as perl sees it, but it can do so with
454 enough certainty that it can be trusted.
455 However, for specific Statement types the PDOM is able to derive
457 additional useful information about their meaning. For the best, most
458 useful, and most heavily used example, see PPI::Statement::Include.
459 A PPI::Structure is any series of tokens contained within matching
461 braces. This includes code blocks, conditions, function argument
462 braces, anonymous array and hash constructors, lists, scoping braces
463 and all other syntactic structures represented by a matching pair of
464 braces, including (although it may not seem obvious at first)
465 "<READLINE>" braces.
466 Each Structure contains none, one, or many Tokens and Structures (the
468 rules for which vary for the different Structure subclasses)
469 Under the PDOM structure rules, a Statement can never directly contain
471 another child Statement, a Structure can never directly contain another
472 child Structure, and a Document can never contain another Document
473 anywhere in the tree.
474 Aside from these three rules, the PDOM tree is extremely flexible.
476 The PDOM at Work
478 To demonstrate the PDOM in use lets start with an example showing how
479 the tree might look for the following chunk of simple Perl code.
480 #!/usr/bin/perl
482 print( "Hello World!" );
484 exit();
486 Translated into a PDOM tree it would have the following structure (as
488 shown via the included PPI::Dumper).
489 PPI::Document
491 PPI::Token::Comment '#!/usr/bin/perl\n'
492 PPI::Token::Whitespace '\n'
493 PPI::Statement::Expression
494 PPI::Token::Bareword 'print'
495 PPI::Structure::List ( ... )
496 PPI::Token::Whitespace ' '
497 PPI::Statement::Expression
498 PPI::Token::Quote::Double '"Hello World!"'
499 PPI::Token::Whitespace ' '
500 PPI::Token::Structure ';'
501 PPI::Token::Whitespace '\n'
502 PPI::Token::Whitespace '\n'
503 PPI::Statement::Expression
504 PPI::Token::Bareword 'exit'
505 PPI::Structure::List ( ... )
506 PPI::Token::Structure ';'
507 PPI::Token::Whitespace '\n'
508 Please note that in this this example, strings are only listed for the
510 actual PPI::Token that contains that string. Structures are listed with
511 the type of brace characters it represents noted.
512 The PPI::Dumper module can be used to generate similar trees yourself.
514 We can make that PDOM dump a little easier to read if we strip out all
516 the whitespace. Here it is again, sans the distracting whitespace
517 tokens.
518 PPI::Document
520 PPI::Token::Comment '#!/usr/bin/perl\n'
521 PPI::Statement::Expression
522 PPI::Token::Bareword 'print'
523 PPI::Structure::List ( ... )
524 PPI::Statement::Expression
525 PPI::Token::Quote::Double '"Hello World!"'
526 PPI::Token::Structure ';'
527 PPI::Statement::Expression
528 PPI::Token::Bareword 'exit'
529 PPI::Structure::List ( ... )
530 PPI::Token::Structure ';'
531 As you can see, the tree can get fairly deep at time, especially when
533 every isolated token in a bracket becomes its own statement. This is
534 needed to allow anything inside the tree the ability to grow. It also
535 makes the search and analysis algorithms much more flexible.
536 Because of the depth and complexity of PDOM trees, a vast number of
538 very easy to use methods have been added wherever possible to help
539 people working with PDOM trees do normal tasks relatively quickly and
540 efficiently.
541 Overview of the Primary Classes
543 The main PPI classes, and links to their own documentation, are listed
544 here in alphabetical order.
545 PPI::Document
547 The Document object, the root of the PDOM.
548 PPI::Document::Fragment
550 A cohesive fragment of a larger Document. Although not of any real
551 current use, it is needed for use in certain internal tree
552 manipulation algorithms.
553 For example, doing things like cut/copy/paste etc. Very similar to
555 a PPI::Document, but has some additional methods and does not
556 represent a lexical scope boundary.
557 A document fragment is also non-serializable, and so cannot be
559 written out to a file.
560 PPI::Dumper
562 A simple class for dumping readable debugging versions of PDOM
563 structures, such as in the demonstration above.
564 PPI::Element
566 The Element class is the abstract base class for all objects within
567 the PDOM
568 PPI::Find
570 Implements an instantiable object form of a PDOM tree search.
571 PPI::Lexer
573 The PPI Lexer. Converts Token streams into PDOM trees.
574 PPI::Node
576 The Node object, the abstract base class for all PDOM objects that
577 can contain other Elements, such as the Document, Statement and
578 Structure objects.
579 PPI::Statement
581 The base class for all Perl statements. Generic "evaluate for side-
582 effects" statements are of this actual type. Other more interesting
583 statement types belong to one of its children.
584 See it's own documentation for a longer description and list of all
586 of the different statement types and sub-classes.
587 PPI::Structure
589 The abstract base class for all structures. A Structure is a
590 language construct consisting of matching braces containing a set
591 of other elements.
592 See the PPI::Structure documentation for a description and list of
594 all of the different structure types and sub-classes.
595 PPI::Token
597 A token is the basic unit of content. At its most basic, a Token is
598 just a string tagged with metadata (its class, and some additional
599 flags in some cases).
600 PPI::Token::_QuoteEngine
602 The PPI::Token::Quote and PPI::Token::QuoteLike classes provide
603 abstract base classes for the many and varied types of quote and
604 quote-like things in Perl. However, much of the actual quote login
605 is implemented in a separate quote engine, based at
606 PPI::Token::_QuoteEngine.
607 Classes that inherit from PPI::Token::Quote, PPI::Token::QuoteLike
609 and PPI::Token::Regexp are generally parsed only by the Quote
610 Engine.
611 PPI::Tokenizer
613 The PPI Tokenizer. One Tokenizer consumes a chunk of text and
614 provides access to a stream of PPI::Token objects.
615 The Tokenizer is very very complicated, to the point where even the
617 author treads carefully when working with it.
618 Most of the complication is the result of optimizations which have
620 tripled the tokenization speed, at the expense of maintainability.
621 We cope with the spaghetti by heavily commenting everything.
622 PPI::Transform
624 The Perl Document Transformation API. Provides a standard interface
625 and abstract base class for objects and classes that manipulate
626 Documents.
627
629 The core PPI distribution is pure Perl and has been kept as tight as
630 possible and with as few dependencies as possible.
631 It should download and install normally on any platform from within the
633 CPAN and CPANPLUS applications, or directly using the distribution
634 tarball. If installing by hand, you may need to install a few small
635 utility modules first. The exact ones will depend on your version of
636 perl.
637 There are no special install instructions for PPI, and the normal "Perl
639 Makefile.PL", "make", "make test", "make install" instructions apply.
640
642 The PPI namespace itself is reserved for the sole use of the modules
643 under the umbrella of the "Parse::Perl" SourceForge project.
644 <http://sf.net/projects/parseperl>
646 You are recommended to use the PPIx:: namespace for PPI-specific
648 modifications or prototypes thereof, or Perl:: for modules which
649 provide a general Perl language-related functions.
650 If what you wish to implement looks like it fits into PPIx:: namespace,
652 you should consider contacting the "Parse::Perl" mailing list (detailed
653 on the SourceForge site) first, as what you want may already be in
654 progress, or you may wish to consider joining the team and doing it
655 within the "Parse::Perl" project itself.
656
658 - Many more analysis and utility methods for PDOM classes
659 - Creation of a PPI::Tutorial document
661 - Add many more key functions to PPI::XS
663 - We can always write more and better unit tests
665 - Complete the full implementation of ->literal (1.200)
667 - Full understanding of scoping (due 1.300)
669
671 This module is stored in an Open Repository at the following address.
672 <http://svn.ali.as/cpan/trunk/PPI>
674 Write access to the repository is made available automatically to any
676 published CPAN author, and to most other volunteers on request.
677 If you are able to submit your bug report in the form of new (failing)
679 unit tests, or can apply your fix directly instead of submitting a
680 patch, you are strongly encouraged to do so, as the author currently
681 maintains over 100 modules and it can take some time to deal with
682 non-"Critical" bug reports or patches.
683 This will also guarentee that your issue will be addressed in the next
685 release of the module.
686 For large changes though, please consider creating a branch so that
688 they can be properly reviewed and trialed before being applied to the
689 trunk.
690 If you cannot provide a direct test or fix, or don't have time to do
692 so, then regular bug reports are still accepted and appreciated via the
693 CPAN bug tracker.
694 <http://rt.cpan.org/NoAuth/ReportBug.html?Queue=PPI>
696 For other issues or questions, contact the "Parse::Perl" project
698 mailing list.
699 For commercial or media-related enquiries, or to have your SVN commit
701 bit enabled, contact the author.
702
704 Adam Kennedy <adamk@cpan.org>
705
707 A huge thank you to Phase N Australia (http://phase-n.com/
708 <http://phase-n.com/>) for permitting the original open sourcing and
709 release of this distribution from what was originally several thousand
710 hours of commercial work.
711 Another big thank you to The Perl Foundation
713 (<http://www.perlfoundation.org/>) for funding for the final big
714 refactoring and completion run.
715 Also, to the various co-maintainers that have contributed both large
717 and small with tests and patches and especially to those rare few who
718 have deep-dived into the guts to (gasp) add a feature.
719 - Dan Brook : PPIx::XPath, Acme::PerlML
721 - Audrey Tang : "Line Noise" Testing
722 - Arjen Laarhoven : Three-element ->location support
723 - Elliot Shank : Perl 5.10 support, five-element ->location
724 And finally, thanks to those brave ( and foolish :) ) souls willing to
726 dive in and use, test drive and provide feedback on PPI before version
727 1.000, in some cases before it made it to beta quality, and still did
728 extremely distasteful things (like eating 50 meg of RAM a second).
729 I owe you all a beer. Corner me somewhere and collect at your
731 convenience. If I missed someone who wasn't in my email history, thank
732 you too :)
733 # In approximate order of appearance
735 - Claes Jacobsson
736 - Michael Schwern
737 - Jeff T. Parsons
738 - CPAN Author "CHOCOLATEBOY"
739 - Robert Rotherberg
740 - CPAN Author "PODMASTER"
741 - Richard Soderberg
742 - Nadim ibn Hamouda el Khemir
743 - Graciliano M. P.
744 - Leon Brocard
745 - Jody Belka
746 - Curtis Ovid
747 - Yuval Kogman
748 - Michael Schilli
749 - Slaven Rezic
750 - Lars Thegler
751 - Tony Stubblebine
752 - Tatsuhiko Miyagawa
753 - CPAN Author "CHROMATIC"
754 - Matisse Enzer
755 - Roy Fulbright
756 - Dan Brook
757 - Johnny Lee
758 - Johan Lindstrom
759 And to single one person out, thanks go to Randal Schwartz who spent a
761 great number of hours in IRC over a critical 6 month period explaining
762 why Perl is impossibly unparsable and constantly shoving evil and ugly
763 corner cases in my face. He remained a tireless devil's advocate, and
764 without his support this project genuinely could never have been
765 completed.
766 So for my schooling in the Deep Magiks, you have my deepest gratitude
768 Randal.
769
771 Copyright 2001 - 2011 Adam Kennedy.
772 This program is free software; you can redistribute it and/or modify it
774 under the same terms as Perl itself.
775 The full text of the license can be found in the LICENSE file included
777 with this module.
778perl v5.12.3 2011-02-26 PPI(3)