Alongside them are my two conversions written in Squatting, a Camping-inspired Web Microframework for Perl, written by John Beppu

The Camping Short, Short Example:

require 'camping'

Camping.goes :HomePage

module HomePage::Controllers

  # The root slash shows the `index' view.
  class Index < R '/'
    def get
      render :index 
    end
  end

  # Any other page name gets sent to the view
  # of the same name.
  #
  #   /index -> Views#index
  #   /sample -> Views#sample
  #
  class Page < R '/(\w+)'
    def get(page_name)
      render page_name
    end
  end

end

module HomePage::Views

  # If you have a `layout' method like this, it
  # will wrap the HTML in the other methods.  The
  # `self << yield' is where the HTML is inserted.
  def layout
    html do
      title { 'My HomePage' }
      body { self << yield }
    end
  end

  # The `index' view.  Inside your views, you express
  # the HTML in Ruby.  See http://code.whytheluckystiff.net/markaby/.
  def index
    p 'Hi my name is Charles.'
    p 'Here are some links:'
    ul do
     li { a 'Google', :href => 'http://google.com' }
     li { a 'A sample page', :href => '/sample' }
    end
  end

  # The `sample' view.
  def sample
    p 'A sample page'
  end
end

The Squatting Short, Short Example:

use strict;
use warnings;

{
  package ShortShortExample;
  use base 'Squatting';
}

{
  package ShortShortExample::Controllers;
  use Squatting ':controllers';
  
  our @C = (

    C( 
      Index => [ '/' ],
      get   => sub {
        my ( $self ) = @_;
        $self->render( 'index' );
      },
    ),
    
    C(
      Page => [ '/(\w+)' ],
      get  => sub {
        my ( $self, $page_name ) = @_;
        $self->render( $page_name );
      }
    ),
    
  );
}

{
  package ShortShortExample::Views;
  use Squatting ':views';
  use HTML::AsSubs;
    
  our @V = (
    
    V(  'html',
      
      layout => sub {
        my ( $self, $v, @yield ) = @_;
        html(
          title ( 'My HomePage' ),
          body ( @yield ),
        )->as_HTML;
      },
      
      index => sub {
        my ( $self, $v ) = @_;
        return (
          p ( 'Hi my name is Charles.' ),
          p ( 'Here are some links:'   ),
          ul (
            li ( a( { href => 'http://google.com' },  'Google' ) ),
            li ( a( { href => '/sample' },  'a sample page'    ) ),
          ),
        );
      },
      
      sample => sub {
        my ( $self ) = @_;
        p ( 'A sample page' );
      },
            
    ),
  );
}

1;

The Camping Tutorial Two:

require 'camping'

Camping.goes :Nuts

module Nuts::Controllers
  class Index < R '/'
    def get
      @t = Time.now.to_s
      render :sundial
    end
  end
end

module Nuts::Views
  def layout
    html do
      head do
        title { "Nuts And GORP" }
      end
      body { self << yield }
    end
  end

  def sundial
    p "The current time is: #{@t}"
  end
end

The Squatting Tutorial Two:

use strict;
use warnings;

{
  package Nuts;
  use base 'Squatting';
}

{ 
  package Nuts::Controllers;
  use Squatting ':controllers';
  
  our @C = (
    C(
      Index => [ '/' ],
      get   => sub { 
        my ( $self ) = @_;
        my $v = $self->v;
        $v->{t} = localtime;
        $self->render( 'sundial' );
      },
    ),
  );
}

{
  package Nuts::Views;
  use Squatting ':views';
  use HTML::AsSubs;
  
  our @V = (
    V(  'html',
    
      layout => sub { 
        my ( $self, $v, @yield ) = @_;
        html (
          head ( 'Nuts And GORP' ),
          body ( @yield ),
        )->as_HTML;
      },
      
      sundial => sub {
        my ( $self, $v ) = @_;
        p ( "The current time is: $v->{t}" );
      },
    ),
  );
}

1;

I’m not going to say much more at this point because I think the code above clearly expresses what’s going on. So just enjoy

/I3az/

Postscript:

The two Camping tutorials were written by Why the lucky stiff the author of Camping. These are no longer available on web because _why was regurgitating them from his own repo/website onto GitHub.

I wrote the Squatting ports of the tutorial back in October 2008 so luckily I had pulled down these Camping tutorials. I found that porting _why’s excellent Camping tutorials were a good way of learning Squatting.

The plan was always to post these on my blog. In fact I have a long list of stuff to post ranging from just a few scribbles to completed prose. I’m just trying to be “logical” about the order of these posts!

So why (excuse the pun!) post these now? The reason will be obvious to most readers…. _why’s strange disappearance from the web overnight.

I not going to conjecture further but I hope all is OK. So this post is my little ode to _why.

Below are some links on this strange event:

• _why is no more (Hacker News)
• _why’s best twitter posts (Hacker News)
• Eulogy to _why (John Resig)

]]> http://transfixedbutnotdead.com/2009/08/20/why-squatting/feed/ 0 draegtun http://transfixedbutnotdead.com/2009/04/27/squatting-060-hits-cpan/ http://transfixedbutnotdead.com/2009/04/27/squatting-060-hits-cpan/#comments Mon, 27 Apr 2009 18:19:08 +0000 draegtun http://transfixedbutnotdead.com/?p=283 ]]> Hot on the hooves of Catalyst 5.8 (CataMoose) hitting CPAN came the latest version of Squatting (web microframework) following very close on its tail.

Here are some new things to look out for in latest Squatting…

• More docs
• Squatting::With::Logs – Simple way to log errors
• Squatting::With::Coro::Debug – Use Coro::Debug to help debug Squatting::On::Continuity apps
• Can now squat on mod_perl 1.3 & mod_perl 2.0
• And a little extra stocking filler called Squatting::H

Squatting::H is hash based object loosely based on Camping::H (Ruby). Here is an example from its pod to make you puurrrr a little

my $cat = Squatting::H->new({
    name => 'kurochan',
    meow => sub { "me" . "o" x length($_[0]->name) . "w" }
});

my $kitty = $cat->clone({ name => 'max' });

$cat->name;                     # "kurochan"
$kitty->name;                   # "max"
$cat->meow;                     # "meoooooooow"
$kitty->meow;                   # "meooow"
$cat->age(3);                   # 3
$kitty->age(2);                 # 2
$kitty->slots;                  # qw(name meow age)

/I3az/


]]> http://transfixedbutnotdead.com/2009/04/27/squatting-060-hits-cpan/feed/ 0 draegtun http://transfixedbutnotdead.com/2009/02/23/the-140-character-webapp-disclaimer/ http://transfixedbutnotdead.com/2009/02/23/the-140-character-webapp-disclaimer/#comments Mon, 23 Feb 2009 11:21:07 +0000 draegtun http://draegtun.wordpress.com/?p=184 ]]> Re: my last blog post

Disclaimer – While its fun to play don’t go writing your webapps in non strict pigeon bad Perl like my post   And also remember to treat all input as dangerous and only output well formed HTML please!!

I’ve formatted the one liners below so that you can see what is going on (at least a bit better!)….

Squatting micro-twitter ( W.pm )…

package W;
use base 'Squatting';


package W::Controllers;
use Squatting':controllers';

@C = C ( 
  w => ['/'], 
  get => sub { 
    ($s) = @_;
    unshift @w, $s->input->{m};
    $s->v->{m} = \@w;
    $s->render('w')
  });


package W::Views;
use Squatting ':views';

@V = V( '',
  w => sub {
    my $r;
    $r .= "<hr>$_" for@{$_[1]->{m}};
    return '<form><input name=m>'.$r
  });

1;

Continuity micro-twitter…


use Continuity;
Continuity->new->loop;

sub main {
  ($r) = @_;
  while (1) {
    $r->print('<form><input name=m>');
    $r->print('<hr>',$_) for @b;
    $r->next;
    unshift @b, $r->param('m')
  }
}

Continuity micro-twitter (save state to file)…


use Continuity;
Continuity->new->loop;

sub main {
  ($r) = @_;
  while (1) {
    $r->print('<form><input name=m>');
    open F, '+<0';
    $r->print('<hr>',$_) for reverse <F>;
    $r->next;
    print F $r->param('m'), "\n"
  }
}

Continuity number counter Twitter compliant webapp!…


use Continuity;
Continuity->new->loop;

sub main {
  ($r) = @_;
  while (1) {
    $r->print('<form><input name=m>');
    $r->next;
    $x += $r->param('m');
    $r->print($x)
  }
}

When I get a mo I may post a “proper” Squatting micro-twitter webapp.

/I3az/


]]> http://transfixedbutnotdead.com/2009/02/23/the-140-character-webapp-disclaimer/feed/ 0 draegtun http://transfixedbutnotdead.com/2009/02/23/the-140-character-webapp/ http://transfixedbutnotdead.com/2009/02/23/the-140-character-webapp/#comments Mon, 23 Feb 2009 10:57:20 +0000 draegtun http://draegtun.wordpress.com/?p=175 ]]> Anyone catch this The 140 Character WebApp Challenge” on Twitter recently?

f055 as been able to create a webapp in Perl that can be posted in a Tweet! Pretty impressive.

What also caught my eye was that some of the responses were using micro webframeworks like Camping & Sinatra (despite original challenge saying only using standard libraries!).

Still fair game… so I’d thought I’d give it a shot with Squatting. Here’s a Squatting version of the f055 micro-twitter webapp…..

package W;use base 'Squatting';package W::Controllers;use Squatting':controllers';@C=C(w=>['/'],get=>sub{($s)=@_;unshift@w,$s->input->{m};$s->v->{m}=\@w;$s->render('w')});package W::Views;use Squatting':views';@V=V('',w=>sub{my $r;$r.="<hr>$_"for@{$_[1]->{m}};return'<form><input name=m>'.$r});1;

Nice eh   Just type “squatting W.pm” and away u go. And like Sinatra it has its own webserver! (Squatting runs by default on Continuity).

So weighs in at 297 chars so too big for Twitter   Still it does well against the already published 308 chars Camping version but still a way to go against the two published Sinatra versions with 140 & 136 chars.

So can it be trimmed? Not easily with those package declarations. But how about a Continuity version!?

use Continuity;Continuity->new->loop;sub main{($r)=@_;while(){$r->print('<form><input name=m>');$r->print('<hr>',$_)for @b;$r->next;unshift@b,$r->param('m')}}

This comes in at a very respectable 159 chars and with its own webserver (and just by doing perl program_name.pl).

However the keen eyed of you may have noticed something different about both Squatting & Continuity scripts compared to what has already been so far posted in the challenge? Mine are not saving state anywhere (ie. to a file). And even more remarkable fire up Squatting app in another web browser and you see the state appear in both browsers.

Unfortunately though all this state is maintained in memory (in package variables in Squatting’s case). So once these webapps are stopped then all is lost   So to retain state after a restart you would have to revert to saving data to file. Here’s an amended Continuity version….

use Continuity;Continuity->new->loop;sub main{($r)=@_;while(){$r->print('<form><input name=m>');open F,'+<0';$r->print('<hr>',$_)for reverse<F>;$r->next;print F$r->param('m'),"\n"}}

BTW. Writing to file in a webapp isn’t a good idea. You have to be careful of race conditions and locks. Continuity uses co-routines so it should be OK compared to normal CGI stuff (I think?).

So now this Continuity micro-twitter comes in at 183 chars. Not bad… but still not Twitter compliant

Still challenge was a Twitter sized “webapp” and so here is a simple number accumulator written in Continuity….

use Continuity;Continuity->new->loop;sub main{($r)=@_;while(){$r->print('<form><input name=m>');$r->next;$x+=$r->param('m');$r->print($x)}}

And it comes it right on the mark at 140 chars

/I3az/


]]> http://transfixedbutnotdead.com/2009/02/23/the-140-character-webapp/feed/ 5 draegtun http://transfixedbutnotdead.com/2008/12/23/pre-render-template-at-squatting-start-up/ http://transfixedbutnotdead.com/2008/12/23/pre-render-template-at-squatting-start-up/#comments Tue, 23 Dec 2008 20:50:21 +0000 draegtun http://draegtun.wordpress.com/?p=120 ]]> In previous post I mentioned that you could build a static CSS file from a template when Squatting first starts up.

Well here’s a complete example using Template Toolkit ( CSS.pm )….

use strict;
use warnings;

{
    package CSS;
    use base 'Squatting';
    use Template;
    
    
    BEGIN {
        our %CONFIG = (
            
            docroot  => './www',    # Continuity htdocs
            static   => '/static',  # Our unique prefix/folder under above
            
            pre_render => {
                
                # CSS profile
                css => {
                    tt   => 'css.tt',       # CSS template 
                    file => 'static.css',   # Name of static file to build
                    v    => {               # template variables
                        colour => 'red',
                    },
                },
                
                # Other pre render template profile...
                # js     => { ... },
                # jquery => { ... },
                
            },

            TT => {
                object   => Template->new( INCLUDE_PATH => './tt' ),
                postfix  => '.tt',
                site_tit => 'Static CSS demo',
            },
        );
    }
    
    # static file handling
    sub continue {
        my $app = shift;
        $app->next::method(
            docroot => $CSS::CONFIG{ docroot },
            staticp => sub { 
                $_[0]->url =~ m/\.(jpg|jpeg|gif|png|css|ico|js|swf)$/ 
            },
            @_
        );
    }
    
    # pre-render stuff
    # for eg. lets build the CSS file on startup as ./www/static/static.css
    my $tt = $CSS::CONFIG{ TT }->{ object };
    my $prefix = $CSS::CONFIG{ docroot } . $CSS::CONFIG{ static } . '/';
    for my $key ( keys %{  $CSS::CONFIG{ pre_render } } ) {
        
        my $render = $CSS::CONFIG{ pre_render }->{ $key };
        
        open my $fh, '>',  $prefix . $render->{ file }
            or die "Unable to write to $render->{file}: $!";

        $tt->process( $render->{ tt }, $render->{ v }, $fh )
            or die "Help!\n";

        close $fh;   
    }

}


{ 
    package CSS::Controllers;
    use Squatting ':controllers';
    
    our @C = (
        C(
            Home => [ '/' ],
            get   => sub { 
                my ( $self ) = @_;
                $self->render( 'home' );
            },
        ),
    );
}


{
    package CSS::Views;
    use Squatting ':views';

    our @V = (

        V(
            'tt',
            tt => $CSS::CONFIG{ TT }->{ object },

            layout => sub {
                my ( $self, $v, $body ) = @_;
                my $tt = $self->{ tt };
                $v->{ site_tit } = $CSS::CONFIG{ TT }->{ site_tit };
                $v->{ body     } = $body;

                my $output;
                $tt->process( 'layout'. $CSS::CONFIG{ TT }->{ postfix }, 
                               $v, \$output)
                    or return view_error( $tt->error );
                return $output;
            },

            _ => sub {
                my ( $self, $v ) = @_;
                my $tt = $self->{ tt };
                $v->{ R } = \&R;
                $v->{ Static } = $CSS::CONFIG{ static };

                my $output;
                $tt->process( $self->{template} . 
                              $CSS::CONFIG{ TT }->{ postfix }, 
                              $v, \$output) 
                    or return view_error( $tt->error );
                return $output;
            },
        ),
    );

    sub view_error {
        my ( $error ) = shift;
        warn $error;
        return "<pre>" . $error . "</pre>\n";   # should HTML encode
    }    
}

1;

$CSS::CONFIG{ pre_render } contains all the profiles to pre-render on. You just need to name a profile and tell it what template (tt), what static filename should be (file) & provide variables for the rendering (v)….

        # CSS profile
        css => {
            tt   => 'css.tt',         # CSS template 
            file => 'static.css',    # Name of static file to build
            v    => {                 # template variables
                colour => 'red',
            },
        },

So above renders css.tt to ./www/static/static.css

Here is an example css.tt


h1 { color: [% colour %]; }

And to make things complete here the other templates (all in ./tt folder)….

# layout.tt
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>[% site_tit %]</title>
  <link rel="stylesheet" href="[% Static %]/static.css" type="text/css" />
</head>

<body>
[% body %]
</body>
</html>

# home.tt
<h1>This should be red</h1>

And if all works fine then you will see “This should be red” in red

/I3az/

NB. This example should only be used with single occurrence of your App running with Squatting::On::Continuity. For multiple occurrences then ideally you need to take care when writing to static file (ie. only write when changed or need locking or have unique static files for each occurrence).


]]> http://transfixedbutnotdead.com/2008/12/23/pre-render-template-at-squatting-start-up/feed/ 0 draegtun http://transfixedbutnotdead.com/2008/12/23/css-views-in-squatting/ http://transfixedbutnotdead.com/2008/12/23/css-views-in-squatting/#comments Tue, 23 Dec 2008 16:43:04 +0000 draegtun http://draegtun.wordpress.com/?p=105 ]]> From my earlier post today you will probably have noticed a problem with CSS files when something like following is used….

body {
	background: url( /images/some_image.gif );
}

What we want this to be is otherwise it won’t find that image file in your static folder…

body {
	background: url( [% Static %]/images/some_image.gif );
}

This means we need to process a CSS template through a Squatting view (see Caveat).

Here’s one way we can do this…..

# Controller code.....
    C( 
        CSS => [ '/css' ],
        get => sub { 
            my $self = shift; 
            $self->headers->{'Content-Type'} = 'text/css'; 
            $self->render( '_app_css' );
        },
    ),

“_app_css.tt” is now your CSS template. The prefixed “_” in the $self->render stops it processing the layout view around it. The layout.tt should now have this line…

    <link rel="stylesheet" href="[% R('CSS') %]" type="text/css" media="screen" title="Demo" />

So when rendered to browser the HTML will look like this…..

    <link rel="stylesheet" href="/css" type="text/css" media="screen" title="Demo" />

So “/css” will call the CSS controller and render the template “_app_css.tt”.

And so Bob’s your Aunty

/I3az/

Caveat: And its a big caveat…. while its nice and could be very useful in lots of cases to serve up dynamic CSS, it is generally going to be a lot better to keep it as a static file and let Apache serve it up and gain all the cache benefits associated with this.

Two possible workarounds are….

• Build static file from TT file. This could even be done when Squatting app is first started. Alternatively look at TT tpage & ttree to do this process manually
• Put caching routines into your CSS View (eg. pre-build rendering, return 304 HTTP code).

NB.: Replace CSS with Javascript in everything above. Everything equally applies.

References

• Using Template Toolkit With Squatting

]]> http://transfixedbutnotdead.com/2008/12/23/css-views-in-squatting/feed/ 1 draegtun http://transfixedbutnotdead.com/2008/12/23/using-squatting-with-reverse-proxy-apache/ http://transfixedbutnotdead.com/2008/12/23/using-squatting-with-reverse-proxy-apache/#comments Tue, 23 Dec 2008 15:18:50 +0000 draegtun http://draegtun.wordpress.com/?p=75 ]]> OK so you’ve just developed your first Squatting (On::Continuity) app and you now want to put it live on your main website/webserver.   So how do you do this?

Well a good seamless & scalable choice is using a Reverse Proxy.   This allows us to map a URL straight to a running Squatting app without too much fuss (famous last words!)

For this exercise I’ve used Apache (2.2) and with a bit trail & error I got below to work for me.

First off we need to switch on reverse proxy.   You will need to following in your httpd.conf file….

    ProxyRequests Off

    <Proxy *>
        Order deny,allow
        Allow from all
    </Proxy>

Now we want to make it point to our Squatting app….

    <VirtualHost *:80>
      DocumentRoot "/var/www/vhosts/www.mysite.com/html"
      ServerName www.mysite.com

      ProxyPass /demo/ http://localhost:4234/demo/
      ProxyPassReverse /demo/ http://localhost:4234/demo/
    </VirtualHost>

Now any requests to www.mysite.com/demo/ are “forwarded” on to your Squatting app running on port 4234.

You may notice that I put a trailing /demo/ on the proxy. This is because the Squatting app is launched via this script….

#!/usr/bin/env perl

use Demo 'On::Continuity', 'With::AccessTrace';
Demo->init;
Demo->relocate( '/demo' );
Demo->continue(port => 4234);

I found this helped the webserver map back to the proxy when requests were made by the browser (eg. www.mysite.com/demo/login). I’m sure there must be another (better?) way but this did work best for me despite endless fiddling with ProxyPass* & RewriteRules ;-(

Restart Apache & start above script in your Squatting app directory and you should find it is now accessible at www.mysite.com/demo/. That is except for any static content u had ;-(

Apache is better suited for pushing out static content so its best to let it deal with this by putting static files somewhere under its document root. However this did present a “best practise” problem between Continuity serving static files during testing and going live with Apache.

My approach to this was to prefix all static URI with “demohtml” using following code in Demo.pm

package Demo;
use strict;
use warnings;
use base 'Squatting';

BEGIN {
    our %CONFIG = (

        static => '/demohtml',
        
        TT => {
            config   => { INCLUDE_PATH => './tt' },
            postfix  => '.tt',
            site_tit => 'Demo',
        }
    );

}

use Demo::Controllers;
use Demo::Views;

# static file handling
sub continue {
    my $app = shift;
    $app->next::method(
        docroot => "./www", 
        staticp => sub { 
            $_[0]->url =~ m/\.(jpg|jpeg|gif|png|css|ico|js|swf)$/ 
        },
        @_
    );
}

1;

Then I would have the following in my View & template(s)…..

# in Demo::Views (good place is in "_" default template)
$v->{ Static } = $Demo::CONFIG{ static };

# and then in TT file(s)....
<link rel="stylesheet" href="[% Static %]/demo.css" type="text/css" media="screen" title="Demo" />

Therefore the above now appears in the HTML like so…

    <link rel="stylesheet" href="/demohtml/demo.css" type="text/css" media="screen" title="Demo" />

This Demo’s static content lives under ./www/demohtml/ in the Squatting app directory so works fine with Continuity during testing. I then sym-linked ./www/demohtml under the Apache document root so that u can see it @ www.mysite.com/demohtml/

So Bob’s your Uncle… u should now find your Squatting app working via reverse proxy as u would expect it to

/I3az/

Further reading… Have a look at App::VW to manage the Squatting apps.

References…

• Apache 2.2 mod_proxy docs
• Apache 2.2 mod_rewrite docs
• Running a Reverse Proxy in Apache

]]> http://transfixedbutnotdead.com/2008/12/23/using-squatting-with-reverse-proxy-apache/feed/ 1 draegtun http://transfixedbutnotdead.com/2008/10/21/using-template-toolkit-with-squatting/ http://transfixedbutnotdead.com/2008/10/21/using-template-toolkit-with-squatting/#comments Tue, 21 Oct 2008 12:04:53 +0000 draegtun http://draegtun.wordpress.com/?p=45 ]]> Been playing with Squatting recently. Its a Perl Web microframework inspired by Camping. For someone like me who is still converting some old CGI apps to Catalyst then this looks like an interesting alternative.

I use Template Toolkit quite a bit so here’s a boilerplate for using TT with Squatting…..

use strict;
use warnings;

{
    package App;
    use base 'Squatting';

    BEGIN {
        our %CONFIG = (
            TT => {
                config   => { INCLUDE_PATH => '.' },
                postfix  => '.tt',
                site_tit => 'TT loves Squatting!',
            }
        );

    }
}

{
    package App::Controllers;
    use Squatting ':controllers';

    our @C = (

        C(
            Home => [ '/' ],
            get  => sub {
                my ( $self )  = @_;
                my $v         = $self->v;
                $v->{ tit }   = 'welcome to my homepage';
                $self->render( 'home' );
            },
        ),
        
        C(
            Page => [ '/path/to/page' ],
            get  => sub {
                my ( $self ) = @_;
                my $v        = $self->v;
                $v->{ tit  } = 'here is another page!';
                $v->{ list } = [ 'one', 'two', 'three' ];
                $self->render( 'page' );
            },
        ),

    );
}

{
    package App::Views;
    use Squatting ':views';
    use Template;

    our @V = (

        V(
            'html',
            tt => Template->new( $App::CONFIG{ TT }->{ config } ),

            layout => sub {
                my ( $self, $v, $body ) = @_;
                my $tt = $self->{ tt };
                $v->{ site_tit } = $App::CONFIG{ TT }->{ site_tit };
                $v->{ body     } = $body;
                
                my $output;
                $tt->process( 'layout'. $App::CONFIG{ TT }->{ postfix }, $v, \$output)
                    or return view_error( $tt->error );
                return $output;
            },

            _ => sub {
                my ( $self, $v ) = @_;
                my $tt = $self->{ tt };
                $v->{ R } = \&R;
                
                my $output;
                $tt->process( $self->{template} . $App::CONFIG{ TT }->{ postfix }, $v, \$output) 
                    or return view_error( $tt->error );
                return $output;
            }

        ),
    );
    
    sub view_error {
        my ( $error ) = shift;
        warn $error;
        return "<pre>" . $error . "</pre>\n";   # really need to HTML encode $error here
    }
}

1;

And here are the templates….

layout.tt


<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
   "http://www.w3.org/TR/html4/strict.dtd">

<html lang="en">
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<title>[% site_tit %]</title>
</head>
<body>
[% body %]
</body>
</html>

home.tt


<h1>Hello.. [% tit %]</h1>

<a href="[% R('Page') %]">Have a look here</a>

page.tt


<h1>Hello again... [% tit %]</h1>

<p>$v->{list}...</p>

<ul>
    [% FOREACH item IN list %]
    <li>[% item %]</li>
    [% END %]
</ul>

<a href="[% R('Home') %]">back to home</a>

Stash variables in Squatting (ie. variables that can used between controller & the view/template) can be set/get by $self->v
NB. “v” is for variables and shouldn’t be confused in anyway with “view” ;-(

Using “layout[.tt]” method/template is optional in Squatting (and Camping) so u can drop this and it will just render the view/template only. The code uses “layout” thus home.tt & page.tt renders as [% body %] via layout.tt

R() returns the route used by the specified controller ( for eg. R(‘Page’) returns “/path/to/page” ). This is quite a handy subroutine to export to TT templates!

So see it working just name above program “App.pm” and put in same directory as the template files and just do squatting App and then point your browser to http://localhost:4234/

Hopefully more on Squatting soon. So if u fancy a bit of fun web programming then give Squatting a go!


]]> http://transfixedbutnotdead.com/2008/10/21/using-template-toolkit-with-squatting/feed/ 3 draegtun