lib/HTML/Zoom.pm

   1 package HTML::Zoom;
   2
   3 use strict;
   4 use warnings FATAL => 'all';
   5
   6 use HTML::Zoom::ZConfig;
   7 use HTML::Zoom::ReadFH;
   8 use HTML::Zoom::Transform;
   9 use HTML::Zoom::TransformBuilder;
  10
  11 our $VERSION = '0.009001';
  12
  13 $VERSION = eval $VERSION;
  14
  15 sub new {
  16   my ($class, $args) = @_;
  17   my $new = {};
  18   $new->{zconfig} = HTML::Zoom::ZConfig->new($args->{zconfig}||{});
  19   bless($new, $class);
  20 }
  21
  22 sub zconfig { shift->_self_or_new->{zconfig} }
  23
  24 sub _self_or_new {
  25   ref($_[0]) ? $_[0] : $_[0]->new
  26 }
  27
  28 sub _with {
  29   bless({ %{$_[0]}, %{$_[1]} }, ref($_[0]));
  30 }
  31
  32 sub from_events {
  33   my $self = shift->_self_or_new;
  34   $self->_with({
  35     initial_events => shift,
  36   });
  37 }
  38
  39 sub from_html {
  40   my $self = shift->_self_or_new;
  41   $self->from_events($self->zconfig->parser->html_to_events($_[0]))
  42 }
  43
  44 sub from_file {
  45   my $self = shift->_self_or_new;
  46   my $filename = shift;
  47   $self->from_html(do { local (@ARGV, $/) = ($filename); <> });
  48 }
  49
  50 sub to_stream {
  51   my $self = shift;
  52   die "No events to build from - forgot to call from_html?"
  53     unless $self->{initial_events};
  54   my $sutils = $self->zconfig->stream_utils;
  55   my $stream = $sutils->stream_from_array(@{$self->{initial_events}});
  56   $stream = $_->apply_to_stream($stream) for @{$self->{transforms}||[]};
  57   $stream
  58 }
  59
  60 sub to_fh {
  61   HTML::Zoom::ReadFH->from_zoom(shift);
  62 }
  63
  64 sub to_events {
  65   my $self = shift;
  66   [ $self->zconfig->stream_utils->stream_to_array($self->to_stream) ];
  67 }
  68
  69 sub run {
  70   my $self = shift;
  71   $self->to_events;
  72   return
  73 }
  74
  75 sub apply {
  76   my ($self, $code) = @_;
  77   local $_ = $self;
  78   $self->$code;
  79 }
  80
  81 sub apply_if {
  82   my ($self, $predicate, $code) = @_;
  83   if($predicate) {
  84     local $_ = $self;
  85     $self->$code;
  86   }
  87   else {
  88     $self;
  89   }
  90 }
  91
  92 sub to_html {
  93   my $self = shift;
  94   $self->zconfig->producer->html_from_stream($self->to_stream);
  95 }
  96
  97 sub memoize {
  98   my $self = shift;
  99   ref($self)->new($self)->from_html($self->to_html);
 100 }
 101
 102 sub with_transform {
 103   my $self = shift->_self_or_new;
 104   my ($transform) = @_;
 105   $self->_with({
 106     transforms => [
 107       @{$self->{transforms}||[]},
 108       $transform
 109     ]
 110   });
 111 }
 112
 113 sub with_filter {
 114   my $self = shift->_self_or_new;
 115   my ($selector, $filter) = @_;
 116   $self->with_transform(
 117     HTML::Zoom::Transform->new({
 118       zconfig => $self->zconfig,
 119       selector => $selector,
 120       filters => [ $filter ]
 121     })
 122   );
 123 }
 124
 125 sub select {
 126   my $self = shift->_self_or_new;
 127   my ($selector) = @_;
 128   return HTML::Zoom::TransformBuilder->new({
 129     zconfig => $self->zconfig,
 130     selector => $selector,
 131     proto => $self
 132   });
 133 }
 134
 135 # There's a bug waiting to happen here: if you do something like
 136 #
 137 # $zoom->select('.foo')
 138 #      ->remove_attribute(class => 'foo')
 139 #      ->then
 140 #      ->well_anything_really
 141 #
 142 # the second action won't execute because it doesn't match anymore.
 143 # Ideally instead we'd merge the match subs but that's more complex to
 144 # implement so I'm deferring it for the moment.
 145
 146 sub then {
 147   my $self = shift;
 148   die "Can't call ->then without a previous transform"
 149     unless $self->{transforms};
 150   $self->select($self->{transforms}->[-1]->selector);
 151 }
 152
 153 1;
 154
 155 =head1 NAME
 156
 157 HTML::Zoom - selector based streaming template engine
 158
 159 =head1 SYNOPSIS
 160
 161   use HTML::Zoom;
 162
 163   my $template = <<HTML;
 164   <html>
 165     <head>
 166       <title>Hello people</title>
 167     </head>
 168     <body>
 169       <h1 id="greeting">Placeholder</h1>
 170       <div id="list">
 171         <span>
 172           <p>Name: <span class="name">Bob</span></p>
 173           <p>Age: <span class="age">23</span></p>
 174         </span>
 175         <hr class="between" />
 176       </div>
 177     </body>
 178   </html>
 179   HTML
 180
 181   my $output = HTML::Zoom
 182     ->from_html($template)
 183     ->select('title, #greeting')->replace_content('Hello world & dog!')
 184     ->select('#list')->repeat_content(
 185         [
 186           sub {
 187             $_->select('.name')->replace_content('Matt')
 188               ->select('.age')->replace_content('26')
 189           },
 190           sub {
 191             $_->select('.name')->replace_content('Mark')
 192               ->select('.age')->replace_content('0x29')
 193           },
 194           sub {
 195             $_->select('.name')->replace_content('Epitaph')
 196               ->select('.age')->replace_content('<redacted>')
 197           },
 198         ],
 199         { repeat_between => '.between' }
 200       )
 201     ->to_html;
 202
 203 will produce:
 204
 205 =begin testinfo
 206
 207   my $expect = <<HTML;
 208
 209 =end testinfo
 210
 211   <html>
 212     <head>
 213       <title>Hello world &amp; dog!</title>
 214     </head>
 215     <body>
 216       <h1 id="greeting">Hello world &amp; dog!</h1>
 217       <div id="list">
 218         <span>
 219           <p>Name: <span class="name">Matt</span></p>
 220           <p>Age: <span class="age">26</span></p>
 221         </span>
 222         <hr class="between" />
 223         <span>
 224           <p>Name: <span class="name">Mark</span></p>
 225           <p>Age: <span class="age">0x29</span></p>
 226         </span>
 227         <hr class="between" />
 228         <span>
 229           <p>Name: <span class="name">Epitaph</span></p>
 230           <p>Age: <span class="age">&lt;redacted&gt;</span></p>
 231         </span>
 232
 233       </div>
 234     </body>
 235   </html>
 236
 237 =begin testinfo
 238
 239   HTML
 240   is($output, $expect, 'Synopsis code works ok');
 241
 242 =end testinfo
 243
 244 =head1 DANGER WILL ROBINSON
 245
 246 This is a 0.9 release. That means that I'm fairly happy the API isn't going
 247 to change in surprising and upsetting ways before 1.0 and a real compatibility
 248 freeze. But it also means that if it turns out there's a mistake the size of
 249 a politician's ego in the API design that I haven't spotted yet there may be
 250 a bit of breakage between here and 1.0. Hopefully not though. Appendages
 251 crossed and all that.
 252
 253 Worse still, the rest of the distribution isn't documented yet. I'm sorry.
 254 I suck. But lots of people have been asking me to ship this, docs or no, so
 255 having got this class itself at least somewhat documented I figured now was
 256 a good time to cut a first real release.
 257
 258 =head1 DESCRIPTION
 259
 260 HTML::Zoom is a lazy, stream oriented, streaming capable, mostly functional,
 261 CSS selector based semantic templating engine for HTML and HTML-like
 262 document formats.
 263
 264 Which is, on the whole, a bit of a mouthful. So let me step back a moment
 265 and explain why you care enough to understand what I mean:
 266
 267 =head2 JQUERY ENVY
 268
 269 HTML::Zoom is the cure for JQuery envy. When your javascript guy pushes a
 270 piece of data into a document by doing:
 271
 272   $('.username').replaceAll(username);
 273
 274 In HTML::Zoom one can write
 275
 276   $zoom->select('.username')->replace_content($username);
 277
 278 which is, I hope, almost as clear, hampered only by the fact that Zoom can't
 279 assume a global document and therefore has nothing quite so simple as the
 280 $() function to get the initial selection.
 281
 282 L<HTML::Zoom::SelectorParser> implements a subset of the JQuery selector
 283 specification, and will continue to track that rather than the W3C standards
 284 for the forseeable future on grounds of pragmatism. Also on grounds of their
 285 spec is written in EN_US rather than EN_W3C, and I read the former much better.
 286
 287 I am happy to admit that it's very, very much a subset at the moment - see the
 288 L<HTML::Zoom::SelectorParser> POD for what's currently there, and expect more
 289 and more to be supported over time as we need it and patch it in.
 290
 291 =head2 CLEAN TEMPLATES
 292
 293 HTML::Zoom is the cure for messy templates. How many times have you looked at
 294 templates like this:
 295
 296   <form action="/somewhere">
 297   [% FOREACH field IN fields %]
 298     <label for="[% field.id %]">[% field.label %]</label>
 299     <input name="[% field.name %]" type="[% field.type %]" value="[% field.value %]" />
 300   [% END %]
 301   </form>
 302
 303 and despaired of the fact that neither the HTML structure nor the logic are
 304 remotely easy to read? Fortunately, with HTML::Zoom we can separate the two
 305 cleanly:
 306
 307   <form class="myform" action="/somewhere">
 308     <label />
 309     <input />
 310   </form>
 311
 312   $zoom->select('.myform')->repeat_content([
 313     map { my $field = $_; sub {
 314
 315      $_->select('label')
 316        ->add_to_attribute( for => $field->{id} )
 317        ->then
 318        ->replace_content( $field->{label} )
 319
 320        ->select('input')
 321        ->add_to_attribute( name => $field->{name} )
 322        ->then
 323        ->add_to_attribute( type => $field->{type} )
 324        ->then
 325        ->add_to_attribute( value => $field->{value} )
 326
 327     } } @fields
 328   ]);
 329
 330 This is, admittedly, very much not shorter. However, it makes it extremely
 331 clear what's happening and therefore less hassle to maintain. Especially
 332 because it allows the designer to fiddle with the HTML without cutting
 333 himself on sharp ELSE clauses, and the developer to add available data to
 334 the template without getting angle bracket cuts on sensitive parts.
 335
 336 Better still, HTML::Zoom knows that it's inserting content into HTML and
 337 can escape it for you - the example template should really have been:
 338
 339   <form action="/somewhere">
 340   [% FOREACH field IN fields %]
 341     <label for="[% field.id | html %]">[% field.label | html %]</label>
 342     <input name="[% field.name | html %]" type="[% field.type | html %]" value="[% field.value | html %]" />
 343   [% END %]
 344   </form>
 345
 346 and frankly I'll take slightly more code any day over *that* crawling horror.
 347
 348 (addendum: I pick on L<Template Toolkit|Template> here specifically because
 349 it's the template system I hate the least - for text templating, I don't
 350 honestly think I'll ever like anything except the next version of Template
 351 Toolkit better - but HTML isn't text. Zoom knows that. Do you?)
 352
 353 =head2 PUTTING THE FUN INTO FUNCTIONAL
 354
 355 The principle of HTML::Zoom is to provide a reusable, functional container
 356 object that lets you build up a set of transforms to be applied; every method
 357 call you make on a zoom object returns a new object, so it's safe to do so
 358 on one somebody else gave you without worrying about altering state (with
 359 the notable exception of ->next for stream objects, which I'll come to later).
 360
 361 So:
 362
 363   my $z2 = $z1->select('.name')->replace_content($name);
 364
 365   my $z3 = $z2->select('.title')->replace_content('Ms.');
 366
 367 each time produces a new Zoom object. If you want to package up a set of
 368 transforms to re-use, HTML::Zoom provides an 'apply' method:
 369
 370   my $add_name = sub { $_->select('.name')->replace_content($name) };
 371
 372   my $same_as_z2 = $z1->apply($add_name);
 373
 374 =head2 LAZINESS IS A VIRTUE
 375
 376 HTML::Zoom does its best to defer doing anything until it's absolutely
 377 required. The only point at which it descends into state is when you force
 378 it to create a stream, directly by:
 379
 380   my $stream = $zoom->to_stream;
 381
 382   while (my $evt = $stream->next) {
 383     # handle zoom event here
 384   }
 385
 386 or indirectly via:
 387
 388   my $final_html = $zoom->to_html;
 389
 390   my $fh = $zoom->to_fh;
 391
 392   while (my $chunk = $fh->getline) {
 393     ...
 394   }
 395
 396 Better still, the $fh returned doesn't create its stream until the first
 397 call to getline, which means that until you call that and force it to be
 398 stateful you can get back to the original stateless Zoom object via:
 399
 400   my $zoom = $fh->to_zoom;
 401
 402 which is exceedingly handy for filtering L<Plack> PSGI responses, among other
 403 things.
 404
 405 Because HTML::Zoom doesn't try and evaluate everything up front, you can
 406 generally put things together in whatever order is most appropriate. This
 407 means that:
 408
 409   my $start = HTML::Zoom->from_html($html);
 410
 411   my $zoom = $start->select('div')->replace_content('THIS IS A DIV!');
 412
 413 and:
 414
 415   my $start = HTML::Zoom->select('div')->replace_content('THIS IS A DIV!');
 416
 417   my $zoom = $start->from_html($html);
 418
 419 will produce equivalent final $zoom objects, thus proving that there can be
 420 more than one way to do it without one of them being a
 421 L<bait and switch|Switch>.
 422
 423 =head2 STOCKTON TO DARLINGTON UNDER STREAM POWER
 424
 425 HTML::Zoom's execution always happens in terms of streams under the hood
 426 - that is, the basic pattern for doing anything is -
 427
 428   my $stream = get_stream_from_somewhere
 429
 430   while (my ($evt) = $stream->next) {
 431     # do something with the event
 432   }
 433
 434 More importantly, all selectors and filters are also built as stream
 435 operations, so a selector and filter pair is effectively:
 436
 437   sub next {
 438     my ($self) = @_;
 439     my $next_evt = $self->parent_stream->next;
 440     if ($self->selector_matches($next_evt)) {
 441       return $self->apply_filter_to($next_evt);
 442     } else {
 443       return $next_evt;
 444     }
 445   }
 446
 447 Internally, things are marginally more complicated than that, but not enough
 448 that you as a user should normally need to care.
 449
 450 In fact, an HTML::Zoom object is mostly just a container for the relevant
 451 information from which to build the final stream that does the real work. A
 452 stream built from a Zoom object is a stream of events from parsing the
 453 initial HTML, wrapped in a filter stream per selector/filter pair provided
 454 as described above.
 455
 456 The upshot of this is that the application of filters works just as well on
 457 streams as on the original Zoom object - in fact, when you run a
 458 L</repeat_content> operation your subroutines are applied to the stream for
 459 that element of the repeat, rather than constructing a new zoom per repeat
 460 element as well.
 461
 462 More concretely:
 463
 464   $_->select('div')->replace_content('I AM A DIV!');
 465
 466 works on both HTML::Zoom objects themselves and HTML::Zoom stream objects and
 467 shares sufficient of the implementation that you can generally forget the
 468 difference - barring the fact that a stream already has state attached so
 469 things like to_fh are no longer available.
 470
 471 =head2 POP! GOES THE WEASEL
 472
 473 ... and by Weasel, I mean layout.
 474
 475 HTML::Zoom's filehandle object supports an additional event key, 'flush',
 476 that is transparent to the rest of the system but indicates to the filehandle
 477 object to end a getline operation at that point and return the HTML so far.
 478
 479 This means that in an environment where streaming output is available, such
 480 as a number of the L<Plack> PSGI handlers, you can add the flush key to an
 481 event in order to ensure that the HTML generated so far is flushed through
 482 to the browser right now. This can be especially useful if you know you're
 483 about to call a web service or a potentially slow database query or similar
 484 to ensure that at least the header/layout of your page renders now, improving
 485 perceived user responsiveness while your application waits around for the
 486 data it needs.
 487
 488 This is currently exposed by the 'flush_before' option to the collect filter,
 489 which incidentally also underlies the replace and repeat filters, so to
 490 indicate we want this behaviour to happen before a query is executed we can
 491 write something like:
 492
 493   $zoom->select('.item')->repeat(sub {
 494     if (my $row = $db_thing->next) {
 495       return sub { $_->select('.item-name')->replace_content($row->name) }
 496     } else {
 497       return
 498     }
 499   }, { flush_before => 1 });
 500
 501 which should have the desired effect given a sufficiently lazy $db_thing (for
 502 example a L<DBIx::Class::ResultSet> object).
 503
 504 =head2 A FISTFUL OF OBJECTS
 505
 506 At the core of an HTML::Zoom system lurks an L<HTML::Zoom::ZConfig> object,
 507 whose purpose is to hang on to the various bits and pieces that things need
 508 so that there's a common way of accessing shared functionality.
 509
 510 Were I a computer scientist I would probably call this an "Inversion of
 511 Control" object - which you'd be welcome to google to learn more about, or
 512 you can just imagine a computer scientist being suspended upside down over
 513 a pit. Either way works for me, I'm a pure maths grad.
 514
 515 The ZConfig object hangs on to one each of the following for you:
 516
 517 =over 4
 518
 519 =item * An HTML parser, normally L<HTML::Zoom::Parser::BuiltIn>
 520
 521 =item * An HTML producer (emitter), normally L<HTML::Zoom::Producer::BuiltIn>
 522
 523 =item * An object to build event filters, normally L<HTML::Zoom::FilterBuilder>
 524
 525 =item * An object to parse CSS selectors, normally L<HTML::Zoom::SelectorParser>
 526
 527 =item * An object to build streams, normally L<HTML::Zoom::StreamUtils>
 528
 529 =back
 530
 531 In theory you could replace any of these with anything you like, but in
 532 practice you're probably best restricting yourself to subclasses, or at
 533 least things that manage to look like the original if you squint a bit.
 534
 535 If you do something more clever than that, or find yourself overriding things
 536 in your ZConfig a lot, please please tell us about it via one of the means
 537 mentioned under L</SUPPORT>.
 538
 539 =head2 SEMANTIC DIDACTIC
 540
 541 Some will argue that overloading CSS selectors to do data stuff is a terrible
 542 idea, and possibly even a step towards the "Concrete Javascript" pattern
 543 (which I abhor) or Smalltalk's Morphic (which I ignore, except for the part
 544 where it keeps reminding me of the late, great Tony Hart's plasticine friend).
 545
 546 To which I say, "eh", "meh", and possibly also "feh". If it really upsets
 547 you, either use extra classes for this (and remove them afterwards) or
 548 use special fake elements or, well, honestly, just use something different.
 549 L<Template::Semantic> provides a similar idea to zoom except using XPath
 550 and XML::LibXML transforms rather than a lightweight streaming approach -
 551 maybe you'd like that better. Or maybe you really did want
 552 L<Template Toolkit|Template> after all. It is still damn good at what it does,
 553 after all.
 554
 555 So far, however, I've found that for new sites the designers I'm working with
 556 generally want to produce nice semantic HTML with classes that represent the
 557 nature of the data rather than the structure of the layout, so sharing them
 558 as a common interface works really well for us.
 559
 560 In the absence of any evidence that overloading CSS selectors has killed
 561 children or unexpectedly set fire to grandmothers - and given microformats
 562 have been around for a while there's been plenty of opportunity for
 563 octagenarian combustion - I'd suggest you give it a try and see if you like it.
 564
 565 =head2 GET THEE TO A SUMMARY!
 566
 567 Erm. Well.
 568
 569 HTML::Zoom is a lazy, stream oriented, streaming capable, mostly functional,
 570 CSS selector based semantic templating engine for HTML and HTML-like
 571 document formats.
 572
 573 But I said that already. Although hopefully by now you have some idea what I
 574 meant when I said it. If you didn't have any idea the first time. I mean, I'm
 575 not trying to call you stupid or anything. Just saying that maybe it wasn't
 576 totally obvious without the explanation. Or something.
 577
 578 Er.
 579
 580 Maybe we should just move on to the method docs.
 581
 582 =head1 METHODS
 583
 584 =head2 new
 585
 586   my $zoom = HTML::Zoom->new;
 587
 588   my $zoom = HTML::Zoom->new({ zconfig => $zconfig });
 589
 590 Create a new empty Zoom object. You can optionally pass an
 591 L<HTML::Zoom::ZConfig> instance if you're trying to override one or more of
 592 the default components.
 593
 594 This method isn't often used directly since several other methods can also
 595 act as constructors, notable L</select> and L</from_html>
 596
 597 =head2 zconfig
 598
 599   my $zconfig = $zoom->zconfig;
 600
 601 Retrieve the L<HTML::Zoom::ZConfig> instance used by this Zoom object. You
 602 shouldn't usually need to call this yourself.
 603
 604 =head2 from_html
 605
 606   my $zoom = HTML::Zoom->from_html($html);
 607
 608   my $z2 = $z1->from_html($html);
 609
 610 Parses the HTML using the current zconfig's parser object and returns a new
 611 zoom instance with that as the source HTML to be transformed.
 612
 613 =head2 from_file
 614
 615   my $zoom = HTML::Zoom->from_file($file);
 616
 617   my $z2 = $z1->from_file($file);
 618
 619 Convenience method - slurps the contents of $file and calls from_html with it.
 620
 621 =head2 to_stream
 622
 623   my $stream = $zoom->to_stream;
 624
 625   while (my ($evt) = $stream->next) {
 626     ...
 627
 628 Creates a stream, starting with a stream of the events from the HTML supplied
 629 via L</from_html> and then wrapping it in turn with each selector+filter pair
 630 that have been applied to the zoom object.
 631
 632 =head2 to_fh
 633
 634   my $fh = $zoom->to_fh;
 635
 636   call_something_expecting_a_filehandle($fh);
 637
 638 Returns an L<HTML::Zoom::ReadFH> instance that will create a stream the first
 639 time its getline method is called and then return all HTML up to the next
 640 event with 'flush' set.
 641
 642 You can pass this filehandle to compliant PSGI handlers (and probably most
 643 web frameworks).
 644
 645 =head2 run
 646
 647   $zoom->run;
 648
 649 Runs the zoom object's transforms without doing anything with the results.
 650
 651 Normally used to get side effects of a zoom run - for example when using
 652 L<HTML::Zoom::FilterBuilder/collect> to slurp events for scraping or layout.
 653
 654 =head2 apply
 655
 656   my $z2 = $z1->apply(sub {
 657     $_->select('div')->replace_content('I AM A DIV!') })
 658   });
 659
 660 Sets $_ to the zoom object and then runs the provided code. Basically syntax
 661 sugar, the following is entirely equivalent:
 662
 663   my $sub = sub {
 664     shift->select('div')->replace_content('I AM A DIV!') })
 665   };
 666
 667   my $z2 = $sub->($z1);
 668
 669 =head2 to_html
 670
 671   my $html = $zoom->to_html;
 672
 673 Runs the zoom processing and returns the resulting HTML.
 674
 675 =head2 memoize
 676
 677   my $z2 = $z1->memoize;
 678
 679 Creates a new zoom whose source HTML is the results of the original zoom's
 680 processing. Effectively syntax sugar for:
 681
 682   my $z2 = HTML::Zoom->from_html($z1->to_html);
 683
 684 but preserves your L<HTML::Zoom::ZConfig> object.
 685
 686 =head2 with_filter
 687
 688   my $zoom = HTML::Zoom->with_filter(
 689     'div', $filter_builder->replace_content('I AM A DIV!')
 690   );
 691
 692   my $z2 = $z1->with_filter(
 693     'div', $filter_builder->replace_content('I AM A DIV!')
 694   );
 695
 696 Lower level interface than L</select> to adding filters to your zoom object.
 697
 698 In normal usage, you probably don't need to call this yourself.
 699
 700 =head2 select
 701
 702   my $zoom = HTML::Zoom->select('div')->replace_content('I AM A DIV!');
 703
 704   my $z2 = $z1->select('div')->replace_content('I AM A DIV!');
 705
 706 Returns an intermediary object of the class L<HTML::Zoom::TransformBuilder>
 707 on which methods of your L<HTML::Zoom::FilterBuilder> object can be called.
 708
 709 In normal usage you should generally always put the pair of method calls
 710 together; the intermediary object isn't designed or expected to stick around.
 711
 712 =head2 then
 713
 714   my $z2 = $z1->select('div')->add_to_attribute(class => 'spoon')
 715                              ->then
 716                              ->replace_content('I AM A DIV!');
 717
 718 Re-runs the previous select to allow you to chain actions together on the
 719 same selector.
 720
 721 =head1 AUTHORS
 722
 723 =over
 724
 725 =item * Matt S. Trout
 726
 727 =back
 728
 729 =head1 LICENSE
 730
 731 This library is free software, you can redistribute it and/or modify
 732 it under the same terms as Perl itself.
 733
 734 =cut
 735