[SP-pm] Validar session no Catalyst
Eden Cardim
edencardim at gmail.com
Wed Jul 13 05:47:50 PDT 2011
>>>>> "Nelson" == Nelson Ferraz <nferraz em gmail.com> writes:
Nelson> Simplicidade é algo difícil de definir, mas todo mundo
Nelson> consegue identificar.
Tenho minhas dúvidas quanto a isso. De fato, a maioria das coisas que as
pessoas costumam identificar como "simples" acabam sendo complicadas lá
na frente. Por exemplo, é bem mais simples descartar uma embalagem na
rua do que guardar e reciclar. Parece ser trivial e inofensivo pra uma
só pessoa fazer, mas se todo mundo fizer igual, vira um problemão
complicado quando a alternativa correta não é muito mais trabalhosa nem
inconveniente mas dá muito retorno a médio e longo prazo. O mesmo se
aplica a desenvolvimento de software, tem coisas que são aparentemente
mais simples, só que com muito pouco ficam complicadas.
Nelson> Vamos começar com um exemplo que eu considero simples:
Nelson> use Mojolicious::Lite;
Nelson> get '/' => sub {
Nelson> my $self = shift;
Nelson> my $name = $self->param('name') || 'world';
Nelson> $self->render( text => "Hello, $name" );
Nelson> };
Nelson> app->start();
Nelson> Esta é uma aplicação mínima, porém completa. Você pode
Nelson> executá-la e testá-la em http://localhost:3000.
--8<---------------cut here---------------start------------->8---
package MyApp;
use Catalyst;
sub root :Path('/') {
my($self, $c) = @_;
my $name = $c->req->param('name');
$c->res->body("Hello, $name");
}
MyApp->setup;
sub { MyApp->run(@_) }
--8<---------------cut here---------------end--------------->8---
Essa é uma aplicação mínima, porém completa. Você pode executá-la e
testá-la em http://localhost:5000 com:
CATALYST_ENGINE=PSGI plackup suaapp.pl
Nelson> Agora, vamos dizer que eu queira usa um template:
Nelson> use Mojolicious::Lite;
Nelson> get '/' => sub {
Nelson> my $self = shift;
Nelson> my $name = $self->param('name') || 'world';
Nelson> $self->stash( name => $name );
Nelson> } => 'index';
Nelson> app->start();
Nelson> __DATA__
Nelson> @@ index.html.ep
Nelson> <h1>Hello, <%= $name %>!</h1>
Nelson> (Sob o ponto de vista didático é conveniene mostrar o
Nelson> template junto com o código, para que as pessoas possam
Nelson> copiar e colar; na prática eu criaria um arquivo dentro de
Nelson> um diretório chamado "templates", que seria reconhecido
Nelson> automaticamente.)
--8<---------------cut here---------------start------------->8---
package MyApp;
use Catalyst;
use String::TT qw/tt/;
sub root :Path('/') {
my($self, $c) = @_;
my $name = $c->req->param('name') || 'world'
$c->res->body(tt <<TT);
<h1>Hello, [% name %]</h1>
TT
}
MyApp->setup;
sub { MyApp->run(@_) };
--8<---------------cut here---------------end--------------->8---
Na prática eu usaria qualquer um dos módulos de template disponíveis no
cpan, colocaria os arquivos no diretório 'root', que seria reconhecido
automaticamente.
Nelson> E se eu quiser usar um arquivo de configuração? Basta criar
Nelson> um arquivo chamado "app.conf". (Onde "app" é igual ao nome
Nelson> da aplicação). Exemplo:
Nelson> {
Nelson> default_name => 'world'
Nelson> }
Nelson> Para usar o arquivo de configuração:
Nelson> use Mojolicious::Lite;
Nelson> plugin 'config';
Nelson> get '/' => sub {
Nelson> my $self = shift;
Nelson> my $name = $self->param('name') || $self->config('default_name');
Nelson> $self->stash( name => $name );
Nelson> } => 'index';
Nelson> app->start();
Nelson> __DATA__
Nelson> @@ index.html.ep
Nelson> <h1>Hello, <%= $name %>!</h1>
--8<---------------cut here---------------start------------->8---
package MyApp;
use Catalyst qw/ConfigLoader/;
use String::TT qw/tt/;
sub root :Path('/') {
my($self, $c) = @_;
my $name = $c->req->param('name')
|| $c->config->{default_name};
$c->res->body(tt <<TT);
<h1>Hello, [% name %]</h1>
TT
}
MyApp->setup;
sub { MyApp->run(@_) };
--8<---------------cut here---------------end--------------->8---
Nelson> Se você quiser acessar a variável de configuração a partir do template:
Nelson> use Mojolicious::Lite;
Nelson> plugin 'config';
Nelson> get '/' => sub {
Nelson> my $self = shift;
Nelson> my $name = $self->param('name');
Nelson> $self->stash( name => $name );
Nelson> } => 'index';
Nelson> app->start();
Nelson> __DATA__
Nelson> @@ index.html.ep
Nelson> <h1>Hello, <%= $name || config('default_name') %>!</h1>
--8<---------------cut here---------------start------------->8---
package MyApp;
use Catalyst qw/ConfigLoader/;
use String::TT qw/tt/;
sub root :Path('/') {
my($self, $c) = @_;
my $name = $c->req->param('name');
$c->res->body(tt <<TT);
<h1>Hello, [% name || c.config.default_name %]</h1>
TT
}
MyApp->setup;
sub { MyApp->run(@_) };
--8<---------------cut here---------------end--------------->8---
Nelson> Vamos, agora, guardar o nome em uma variável de sessão:
Nelson> use Mojolicious::Lite;
Nelson> plugin 'config';
Nelson>
Nelson> get '/' => sub {
Nelson> my $self = shift;
Nelson> my $name = $self->param('name')
Nelson> || $self->session('name')
Nelson> || $self->config('default_name');
Nelson> $self->session( name => $name );
Nelson> $self->stash( name => $name );
Nelson> } => 'index';
Nelson> app->start();
Nelson> __DATA__
Nelson> @@ index.html.ep
Nelson> <h1>Hello, <%= $name %>!</h1>
Nelson> Aí está: um exemplo completo, com template, arquivo de
Nelson> configuração externo, e sessão.
--8<---------------cut here---------------start------------->8---
package MyApp;
use Catalyst qw/
ConfigLoader
Session
Session::State::Cookie
Session::Store::FastMmap
/;
use String::TT qw/tt/;
sub root :Path('/') {
my($self, $c) = @_;
my $name = $c->req->param('name')
|| $c->session->{name}
|| $c->config->{default_name};
$c->res->body(tt <<TT);
<h1>Hello, [% name %]</h1>
TT
}
MyApp->setup;
sub { MyApp->run(@_) };
--8<---------------cut here---------------end--------------->8---
Nelson> Compare com a página de documentação do Catalyst::Plugin::Session:
Essa comparação é injusta, a documentação de módulo correto para
comparação seria o MojoX::Session ou o Mojolicious::Session
<snip>
Nelson> Este é o "problema de complexidade".
Continuo não entendendo, o problema é a falta de documentação concisa?
Porque isso pode ser providenciado, aliás, vou submeter esses exemplos
pra documentação hoje mesmo, se for esse o problema. O que eu não
entendo é a preferência por escrever 30 mil linhas de código
mal-testado, pra ganhar 50 caracteres com sintaxe (que vai ser
descartada de qualquer forma, quando a aplicação crescer) invés de
escrever um documento de POD.
Nelson> Se o Catalyst::Lite puder reunir a simplicidade do
Nelson> Mojolicious com a solidez do Catalyst, creio que este será o
Nelson> melhor dos dois mundos.
Não tem dois mundos, e eu não consigo entender porque as pessoas acham
que é diferente, mudam só os caracteres do código fonte, mas a semântica
do framework é idêntica, aliás, o Mojolicious é menos flexível porque
você não pode optar por não instalar todo o cruft que vem junto com
ele. Como sempre, explicar todas as possibilidades de um sistema
flexível dentro de um manual é bem difícil, mas certamente é mais fácil
que escrever 30 mil linhas de código.
--
Eden Cardim Need help with your Catalyst or DBIx::Class project?
Code Monkey http://www.shadowcat.co.uk/catalyst/
Shadowcat Systems Ltd. Want a managed development or deployment platform?
http://blog.edencardim.com/ http://www.shadowcat.co.uk/servers/
http://twitter.com/#!/edenc
More information about the SaoPaulo-pm
mailing list