Sample files

Quick and dirty LOOM building: .pm and .html in same directory

 package html::Greeting;
 
 use strict;
 use warnings;
 
 use base qw(HTML::Seamstress);
 
 
 sub new {
   my $tree  = __PACKAGE__->new_from_file('html/greeting.html');
   $tree;
 }
 
 
 sub process {
   
   my $tree = shift;
 
   my %replace = (
     name         => 'Jim Rays',
     lucky_number => 222
    );
 
   $tree->look_down(id => $_)->replace_content($replace{$_})
     for (keys %replace) ;
 }
 
 
 1;

which we make nice tight application-level use of like this:

 use html::Greeting;
 
 my $tree = html::Greeting->new;
 
 $tree->process;
 
 print $tree->as_HTML(undef, ' ');

Cleaning up our Perl class

We are flowing smoothly now with nice tight code in our application. But should we be happy with this module? I see a few drawbacks which require improvement:

• our file name is given as a relative path name

  Relative paths are fine as long as we are certain to start in the same directory, but we cannot be sure of that when building applications, so we need an absolute path.

• we had to manually create this package

Let's fix the first problem first.

Make path to HTML file absolute

Again, Seamstress just happens to have a subroutine which guesses the name of the HTML file associated with a Seamstress-style Perl module. It is called "html()" and here we see it in use to give us the path to our file in absolute fashion:

 package html::GreetingAbs;
 
 use strict;
 use warnings;
 
 use base qw(HTML::Seamstress);
 
 use Data::Dumper;
 print Dumper \%INC;
 
 our $html = __PACKAGE__->html(__FILE__ , 'html'); 
 
 {
   last;
   
 # The stuff in these braces is not for the first reading of this!
 
 # $html is 
 # /ernest/dev/seamstress/lib/HTML/Seamstress/Quickstart/html/GreetingAbs.html
 # but the real HTML file is greeting.html not GreetingAbs.html
 $html =~ s!Abs!!;
 
 # change Greeting to greeting since file is greeting.html not Greeting.html
 $html =~ s!Greeting!greeting!;
 }
 
 
 
 sub new {
   my $tree  = __PACKAGE__->new_from_file($html);
   $tree;
 }
 
 
 sub process {
   
   my $tree = shift;
 
   my %replace = (
     name         => 'Jim Rays',
     lucky_number => 222
    );
 
   $tree->look_down(id => $_)->replace_content($replace{$_})
     for (keys %replace) ;
 }
 
 
 1;

and main code body is still the same:

 use html::GreetingAbs;
 
 my $tree = html::GreetingAbs->new;
 
 $tree->process;
 
 print $tree->as_HTML(undef, ' ');

Slow and clean LOOM building: .pm and .html in different directory

 package Local::Seamstress::Base;
 
 use base qw(HTML::Seamstress);
 
 
 sub comp_root {
   '/ernest/dev/seamstress/lib/HTML/Seamstress/Quickstart/html';
 }
 
 1;

This class will make it easy to track down the directory of our HTML files.

The LOOM class inherits from it and makes use of it in its constructor:

 package html::Greeting;
 
 use strict;
 use warnings;
 
 use base qw(Local::Seamstress::Base); # not HTML::Seamstress!
                                      # we need an intermediate base class
                                      # with the comp_root() method so that
                                      # we can get an absolute path to the 
                                      # HTML file... remember this is an
                                      # example where the LOOM is in a 
                                      # different directory to the the HTML
                                      # file it operates on.
 
 
 sub new {
   my $comp_root = __PACKAGE__->comp_root();
   my $html_file = "$comp_root/greeting.html";
   warn "html_file: $html_file";
   my $tree  = __PACKAGE__->new_from_file($html_file);
   $tree;
 }
 
 
 sub process {
   
   my $tree = shift;
 
   my %replace = (
     name         => 'Slow Clean Greeting Machine',
     lucky_number => 737
    );
 
   $tree->look_down(id => $_)->replace_content($replace{$_})
     for (keys %replace) ;
 }
 
 
 1;

And out main body code is just as tight. We have a few statements to make sure to use the right version of "html::Greeting", but other than that, no changes:

 use lib 'lib';
 use html::Greeting;
 
 use Data::Dumper;
 
 print Dumper \%INC; # shows we are using the hhtml::Greeting which
                     # obtains its file via HTML::Seamstress::Base::comp_root()
                     # instead of via __PACKAGE__->html( )
 
 my $tree = html::Greeting->new;
 
 $tree->process;
 
 print $tree->as_HTML(undef, ' ');

Slow and clean has extra programming advantages

Slow and clean is not just a different way to do the same thing. By creating a local base class, you have full control over how to connect an HTML file to your Perl code.

Your HTML designer can have his files mounted elsewhere. And you dont

•

infect his directory with your ".pm" files =item * infect his HTML with all sorts of dynamic HTML logic

And being infection-free is the way I like it.. in Perl and uhhh... other endeavors.

Not recommended slow clean way: Inline the HTML

There is no Seamstress API or utility support for this. But it is an idea and I just wanted to mention it for completeness. You can create a .pm with the HTML along the lines of this.

 package html::hello_world;

 sub new {...}

 sub process {...} 

 __HTML__
 <html>
  <head>
    ...
  </head>
  <body>
    ...
  </body>

 </html>

And then you could use File::Slurp to read it in and submit an appropriate "HTML::Seamstress::new_from_content()" method to do the proper blessings.

But I don't like this approach. It makes it hard to stay synchronized with the designer as he continually makes updates.

Use subroutines and Params::Validate to "componentize" your operations

If you do this, then you can control the dynamic HTML generation by parameterizing your subs properly. This advice will make more sense as you do more complex things with Seamstress

Now you're ready for the big time! Have fun!

Identify HTML elements by class tags if you plan to loop them

For example here is some Template code:

 [% FOR column = item.columns('view') %]
    <b class="title">[% column %]</b><br/>
    [% item.$column %]<br/><br/>
 [% END %]

Here is how I converted it to a Seamstress document:

 <span class="columns_view">
    <b class="title">column_name</b><br/>
    <span class="item_column">column_value</span><br/><br/>
 </span>