Monsenhor

YAC (YACCMS (Yet Another Catalyst CMS))
Publicado em 01/09/2010

YAC (YACCMS (Yet Another Catalyst CMS))

Neste ensaio procuramos apresentar o desenvolvimento inicial do YAC, o CMS mais simples possível.

Um CMS básico e extensível para a comunidade de desenvolvedores perl. Ajude a realizar este trabalho!

Após diversos estudos escolhemos o framework Catalyst como base para todo o projeto por sua grande compatibilidade com as melhores práticas e ferramentas da programação moderna.

A melhor característica é a sua extensibilidade. Para criar uma extensão ou componente do Catalyst basta usar o Moose, um framework pós-moderno no paradigma POO, no CPAN.

Procuramos dividir o trabalho em 5 etapas:

Projeto

Estudo dos CMSs em uso e suas características, objetivando encontrar lacunas e as principais demandas dos usuários. Definição dos primeiros cases, modelos e conceitos.

Infra estrutura

Passos básicos para o início de um projeto de acordo com as melhores práticas em perl

Implementação básica do YAC

Usando os helpers do Catalyst implementar a estrutura básica do YAC

Implementação do gancho para extensões

Arquitetura e orientações para extender o YAC.

Implementação da primeira extensão

Extender view e control implementando o plugin fckeditor

Primeiros passos

Projeto

Uma visão do produto

Um CMS (Content Management System) ou Sistema de Gerenciamento de conteúdo pode ser uma ferramenta web usada em alguns negócios na Internet para publicação e administração de multimídia. O líder deste mercado é certamente o Drupal, um CMS baseado em php, produto de referência usado por todos, considerado ferramenta chave na campanha de Obama à presidência dos Estados Unidos. O número de usuários do CMS Drupal ampliou consideravelmente (inclusive como escolha de designers e desenvolvedores), assim como o número de contribuições provindas da comunidade, um grande esforço de programação fruto da demanda significativa por estes códigos devido ao seu sucesso.

Geralmente a multimídia servida em um CMS precisa se integrar com outros sistemas como CRMs, ERPs ou outros sistemas legados da empresa. A maior oportunidade em CMS's para programadores está justamente no desenvolvimento destas ferramentas de integração, sistemas de plugin e extensões. Este é o caso do Drupal. Sua simplicidade minimalística é seu maior valor. Programadores podem desenvolver ganchos de seus sistemas no CMS e usuários finais podem plugá-los no website instantaneamente.

O segredo: O designer (ou qualquer um) pode criar um website funcional sem qualquer código. Um CMS precisa de uma interface de usuário simples e clara. Mas a integração com outros sistemas, talvez o principal foco do desenvolvedor esteja nesta aplicação externa, precisa ser simples também. Resultado final: Produtividade.

Nos mundos Java, Python, Ruby e Asp encontramos similares: Typo, OpenCms, Django, Plone. Alguns simples, outros com mais recursos.

Concorrentes

Opções em Perl

Uma das principais característica do Perl e eu diria uma virtude de qualquer pessoa inteligente é poder fazer a mesma coisa de diversas formas.

Entre as ferramentas Perl não podemos deixar de falar do MovableType. O YAC não é concorrente direto do MovableType, que se integra no Catalyst e da mesma forma irá integrar-se em nossa implementação. O paradigma do YAC é diferente pelo foco na simplicidade e minimalismo. Será tranquilo iniciar um projeto com YAC e integrar o MovableType a qualquer momento.

Conclusão

O projeto Catalyst seria muito enriquecido com esta distribuição. Um CMS básico e extensivel, com os olhos no usuário final e interfaces que podem facilitar também o trabalho dos desenvolvedores. Um CMS mais simples que Drupal mas com o poder do CPAN e do Catalyst.

Vamos considerar também a integração com as ferramentas perl disponívies via cpan como Reaction, Mojo e Dancer.

Infra estrutura

* instalar o Catalyst e criar a base do YAC
    $> sudo cpan Catalyst
    $> sudo cpan Catalyst::Model::DBIC::Schema
    $> catalyst.pl YAC
    $> cd YAC

* criar controles
    $> ./script/yac_create.pl controller Edit
    $> ./script/yac_create.pl controller Hack
    $> ./script/yac_create.pl controller Admin

* criar view
    $> ./script/yac_create.pl view Stack TT
    $> ./script/yac_create.pl view Back TT

* criar modelos

Vamos implementar o modelo no banco de dados sqlite! Ideal para esta aplicação.

http://www.sqlite.org/

Mas poderíamos usar mysql, postgres ou outro banco qualquer que o perl suportar.

Preferimos o editor vim:

    $> vi yac.sql

Edite o arquivo yac.sql e coloque o código abaixo:

    --
    -- Cria a base de dados mais simples possEvel para um cms
    -- Tabelas: users e stacks
    --
    PRAGMA foreign_keys = ON;
    -- stack_id aponta o stack pai ou 0 se stack raiz
    CREATE TABLE stack (
            id           INTEGER PRIMARY KEY,
            stack_id     INTEGER,
            content      TEXT
    );
    -- 'stack_userr' E uma tabela relacionamento muitos-muitos entre stacks e userss
    CREATE TABLE stack_user (
            stack_id  INTEGER REFERENCES stack(id) ON DELETE CASCADE ON UPDATE CASCADE,
            user_id   INTEGER REFERENCES user(id)  ON DELETE CASCADE ON UPDATE CASCADE,
            PRIMARY KEY (stack_id, user_id)
    );
    CREATE TABLE user (
            id          INTEGER PRIMARY KEY,
            first_name  TEXT,
            last_name   TEXT,
            login       TEXT,
            password    TEXT,
            role        INTEGER
    );
    ---
    --- Dados de exemplo
    ---
    INSERT INTO stack VALUES (1, 0, '

Sou a index.tpage

menu'); INSERT INTO stack VALUES (2, 1, '

  • menu1'); INSERT INTO stack VALUES (3, 1, '
  • menu2'); INSERT INTO stack VALUES (4, 1, '
  • menu3'); INSERT INTO stack VALUES (5, 1, '
  • menu4'); INSERT INTO user VALUES (1, 'Greg', 'Bastien', 'greg@cpan.org', 'novasenha', 1); INSERT INTO user VALUES (2, 'Sara', 'Nasseh', 'sara@pan.org', 'novasenha', 1); INSERT INTO user VALUES (3, 'Christian', 'Degu', 'degu@cpan.org', 'novasenha', 1); INSERT INTO user VALUES (4, 'Richard', 'Stevens', 'stev@cpan.org', 'novasenha', 1); INSERT INTO user VALUES (5, 'Douglas', 'Comer', 'comer@gmail.com', 'novasenha', 2); INSERT INTO user VALUES (9, 'Ricardo', 'Filipo', 'filipo@kobkob.com.br', 'novasenha',3); INSERT INTO stack_user VALUES (1, 1); INSERT INTO stack_user VALUES (1, 2); INSERT INTO stack_user VALUES (1, 3); INSERT INTO stack_user VALUES (2, 4); INSERT INTO stack_user VALUES (3, 5); INSERT INTO stack_user VALUES (4, 6); INSERT INTO stack_user VALUES (4, 7); INSERT INTO stack_user VALUES (5, 8);
  • Agora vamos criar a base de dados

        $> sqlite3 yac.db  ./script/yac_create.pl model YAC DBIC::Schema create=static dbi:SQLite:
    
        $> ./script/yac_create.pl model YAC DBIC::Schema YAC::Schema \
            create=static dbi:SQLite:yac.db \
            on_connect_do="PRAGMA foreign_keys = ON"
    
    

    O CMS mínimo

    Arquitetura

    A unidade básica do YAC é o Stack, um objeto com 3 métodos:

    * url

    A url única deste stack. Acessar a url retornará o mesmo que o método content();

    * content

    Os dados do conteúdo. Uma string. Provavelmente em html.

    * stacks

    Array com os stacks contidos neste stack

    Será possível herdar um Stack definindo-se novos métodos.

    Além da interface default (Play), a máquina de estados do YAC apresenta ainda 3 outras interfaces.

    Play

    Default, apresenta os Stacks.

    Edit

    Interface de edição de Stack.

    Hack

    Interface de desenvolvimento de Stack.

    Admin

    Interface de administração e gestão de usuários.

    Exemplo

        use YAC::Stack;
    
    

    Instanciar um Stack:

        my $coolStack = new YAC::Stack;
    
    

    Montar o Stack, editando url e conteúdo

        $coolStack->url ('my/coolStack');
        my $url = $coolStack->url();
    
        $html = "

    Oi gente!"; $coolStack->content($html);

    Acessar o Stack na Web

        use LWP::Curl;
    
        my $browser = LWP::Curl->new();
        my $hello = $browser->get('my/coolStack');
        my $content = "$hello 

    Benvindos ao YAC!";

    Um Stack então pode ser apresentado, editado ou construído e é acessado em determinada url.

    TODO

    Extensões

    • definir ganchos para as extensões

    Extensão exemplo

    • implementar a extensão fckeditor

    --------------------------------------------------------------------------------

    --------------------------------------------------------------------------------

    NOME

    YAC (YACCMS (Yet Another Catalyst CMS))

    Colofon:

    YAC lembra "Yeast Artificial Chromosome. Yeah! A levedura é o nosso mascote. See http://en.wikipedia.org/wiki/Yeast

    VERSÃO

    Versão 0.01

    AUTOR

    Monsenhor, <ricardo.filipo at gmail.com>

    SINOPSE

    O CMS mais simples que existe.

        use YACCMS;
    
        my $web = new YACCMS;
        $web->run();
        # go to web!
    
    

    Design Pattern

    O ponto de vista do usuário leigo é o foco do YAC. Eu não tenho dúvida que seria muito mais fácil para o nosso pequeno YAC se não tivesse que lidar com usuários. Especialmente os que são leigos nas aventuras da TI. Mas nada disto teria sentido se o YAC não fosse pensado para ser usado por alguém.

    Na verdade se houver alguma complexidade no YAC estará relacionada com o desenvolvimento de interfaces e agentes voltados à facilidade do usuário. O nosso objetivo é permitir que o usuário pense e trabalhe em seus assuntos, sem ter que se preocupar com detalhes de como isto se realiza. Infelizmente o YAC ainda não pode entender o usuário por telepatia, sim, seria certamente a melhor abordagem caso já existisse a tecnologia, então nos contentaremos com as interfaces em uso, como Html e Ajax.

    Produtos como Drupal, líder do mercado, apresentam, apesar de sua grande maleabilidade e integrabilidade com outros sistemas, uma interface engessada e ainda complexa para um usuário médio. A proposta do YAC é ser o mais simples possível, o mais básico possível. O objetivo do YAC é administrar apenas cada elemento unitário de cada vez. A unidade é o Stack.

    Em nossa opinião o melhor desenho para um CMS deve ser a Pilha. Mas pensamos a pilha como uma colagem, os objetos não precisam ser todos da mesma forma material ou tamanho. A estrutura de camadas do css ou folhas de estilo funciona assim. Cada objeto depositado na pilha (a tela do site) é um url definido como um elemento do YAC, uma pilha de pilhas.

    O nosso mascote, o fungo, apresenta uma estrutura muito parecida. Uma colônia de fungos forma desenhos, cores e formas de acordo com o ambiente. Cada pequeno fungo acha seu lugar e a pilha de fungos forma como que um indivíduo único, um local de vida, um site.

    Stack

      ----------
      | Stack  |----->  URL                           # Tela do site
      ----------
          |       ----------
          |---->  | Stack  |----->  URL               # CabeEalho
          |       ----------
          |          |       ----------
          |          |---->  | Stack  |----->  URL    # Logomarca
          |          |       ----------
          |          |       ----------
          |          |---->  | Stack  |----->  URL    # Menu
          |                  ----------
          |       ----------
          |---->  | Stack  |----->  URL               # Texto em html
                  ----------
    
    
    
    
    

    Um Stack está relacionado a uma URL, retorna um array de Stacks e pode ser herdado e livremente modificado.

    Cada Stack pode ser apresentado, editado ou construido (hack). Além disso um Stac possui um usuário responsável.

    MÉTODOS

    new

    Retorna uma instância do controlador do aplicativo. Agora voê pode rodar ou parar o YAC.

    run

    Roda o daemon http na porta $port. Default em 80.

        my $port = 80 ;
        $web->run ($port) ;
    
    

    stop

        $web->stop();
    
    

    Para o daemon.

    YAC

    Imnplementação em Catalyst

    YAC - Baseado em Catalyst

    SINOPSE

        script/yac_server.pl
    
    

    DESCRIÇÃO

    Estrutura de Controle

    O YAC pode carregar uma das 4 máquinas:

        . Play
        . Edit
        . Admin
        . Hack
    
    

    Cada máquina exige que o usuário possua determinados função e direitos de acesso.

    * Máquina Play

    A Máquina Play ou controlador Root será sempre a default. Aqui o usuário poderá visualizar os conteúdos em mídia e acessar os menus básicos para navegação.

    * Máquina Edit

    Um usuário logado com direitos de edição pode acessar a máquina Edit para editar seu trabalho.

    O editor default é html. Outros editores como link, código, imagem, animaçã, xml, svg, json e outros podem ser adicionados como extensões.

    O menu é o mesmo que o da máquina Play mais os menus de dados pessoais e de edição. Também serão acrescentadas interfaces para edição de dados pessoais e outros em extensões. Estes novos editores serão integrados na mesma interface.

    * Máquina Admin

    Com direitos de administrador o usuário poderá acessar a máquina Admin.

    Apresenta interfaces para editar e administrar usuários, seus dados e trabalhos. Permite atividades administrativas no CMS's como startup/shutdown do servidor e habilitar/desabilitar extensões.

    Menus são os mesmos da máquina Edit mais os menus de usuários e administrativos.

    * Máquina Hack

    Com direitos de hacker o usuário poderá usar a Máquina Hack.

    Apresenta interfaces para o desenvolvimento de plugins, acesso ao Catalyst: hooks e helpers. Objetiva o design e construção da arquitetura do CMS como criar widgets, desenvolver novas funcionalidades ou uma nova extensão.

    Uma idéia interessante é desenvolver interface para servidores de versionamento, como git, svn e cvs.

    Modelo

    * Stack

    O acesso ao conteúdo. A única coisa sem a qual o YAC não existe.

    Voce certamente vai criar stacks sensacionais!!

    Os stacks especiais implementados no core do YAC: Content, Control e Widget.

    Control

    O gerenciador de menus. Tem mais 2 métodos: url e name

    Content

    Conteúdo em html.

    Widget

    Conteúdo em javascript.

    * Auth

    Classe de autenticação. Trata usuários, regras e direitos.

    * User

    Classe que representa o usuário.

    * Layout

    Objetos Layout são templates do view TT, do Catalyst, armazenados em banco de dados.

    * Extension

    Extensões são classes do Moose.

    Core Extensions

    • Media Player
    • Imagens em slides e carrossel
    • Diálogos e hooks para o jqueryUI
    • fkceditor
    • jsLinb visual editor

    AGRADECIMENTOS

    Aos amigos do do SP-pm, Rio-pm e Cascavel-pm pelo incentivo. Obrigado!

    Bibliografia

       L
       L
       L
       L
       L
       L
       L
       L
       L
       L
       L
    
    

    LICENSE AND COPYRIGHT

    blog comments powered by Disqus