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/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