Pv Gomes Developer

Trabalhando nas nuvens, integrando o SDK da AWS para S3 com PHP

noreply@blogger.com (Anonymous) — Tue, 16 Dec 2014 21:17:00 -0200

Olá pessoal. Nesse artigo vamos mostrar algo que anda sendo bem utilizado no dia a dia dos desenvolvedores em geral, que é a integração com a nuvem. Nesse caso em específico com os percusores dela a toda poderosa Amazon.

Legal, mas ai você pergunta o que é o S3?

Aqui vai uma pequena descrição:

"O Amazon S3 é o armazenamento para a internet. Ele foi projetado para facilitar a computação de escala na web para os desenvolvedores.

O Amazon S3 fornece uma interface simples de serviços da web que pode ser usada para armazenar e recuperar qualquer quantidade de dados, a qualquer momento e de qualquer lugar na web. Ele concede acesso a todos os desenvolvedores para a mesma infraestrutura altamente escalável, confiável, segura, rápida e econômica que a Amazon utiliza para executar sua própria rede global de sites da web. O serviço visa maximizar os benefícios de escala e poder passar esses benefícios para os desenvolvedores." (http://aws.amazon.com/pt/s3/)

Pois bem, por onde eu começo a fazer a integração?
A Amazon desenvolveu um SDK PHP para todos os serviços da AWS sendo assim, vamos utilizar esse client para desenvolver nossa integração.

Talvez você esteja dizendo nesse momento "Vai ser díficil integrar esse SDK no meu framework, será que não existe um client da S3 feito por ele?". Bem minha resposta sobre isso é que existe sim, no meu caso eu fui fazer a integração em um sistema legado que foi feito em Zend Framework 1.12 e então pensei em utilizar o client desse framework "Full Stack", e o que eu conclui depois de 1 dia integrando é que eu NÃO devo utilizar esse client extremamente descontinuado e com vários metódos não implementados. A verdade é que a Zend reconheceu quando lançou o ZF2 que não são eles que devem fornecer esse client, pessoas especializadas nisso já vão fazer, deixa o pessoal focado em Amazon cuidar disso, e tem mais, com o composer tudo fica mais fácil então relaxa :).

"Pow, mas composer no ZF1? Por que não? Basta adicionar a vendor no autoload e toca o barco".

Claro que a proposta desse artigo não é falar sobre arquitetura de sistema pq se fosse eu provavelmente não utilizaria o meu legado e partiria para outra abordagem. Mas a questão aqui é que eu precisava em pouco tempo alterar a implementação nesse sistema legado, que utilizava as funções de file do php e fazia a persistencia dos arquivos em uns diretorios no mesmo servidor da aplicação (DEUSSS PERDOE QUEM NÃO IMPLEMENTOU UMA APLICAÇÃO FLEXIVEL O BASTANTE, NÃO CONHECIAMOS AS NUVENS).

Pois bem então a primeira abordagem no meu caso foi colocar o composer no ZF1 e isso foi algo bem simples, em 2 minutinhos eu ja tinha tudo funcionando com o SDK prontinho para meu framework utilizar.

continua...

Iniciando com o Docker

noreply@blogger.com (Anonymous) — Mon, 8 Sep 2014 10:54:00 -0300

Acredito que precisamos estar ligados em tudo aquilo que acontece no mundo da TI, precisamos ser cuidadosos com as novidades mas acima de tudo ter uma opinião bem fundamentada sobre as coisas. Eu comecei esse post com essa frase pois tenho passado por um processo profissional em que tenho conhecido muita coisa nova (principalmente aquilo que se refere a ferramentas para escalabilidade), sempre que posso eu ainda leio sobre qualidade de código, design e arquitetura até porque, é disso que eu gosto e acredito que seja meu minha melhor qualidade. Mas, como eu já disse precisamos estar ligado no mundo e pensando nisso vou tentar iniciar uma serie de posts (não quero prometer nada) em que eu falo sobre ambiente de desenvolvimento, tanto em dev como live. A principio eu queria ter uma versatilidade em meus ambientes de desenvolvimento sem estar muito atrelado a uma unica máquina, e ai eu fui pesquisar sobre a Vagrant que, é uma forma de virtualizar um ambiente bem feito, mas que no fim das contas é muito pesado para aquilo que eu preciso fazer e para meu hardware em alguns momentos. Foi então que no PHP Conference 2013 eu vi a grande figura Elton Minetto falando sobre Docker, ele deu apenas uma pincelada mas já me interessou ir pesquisar pois a proposta dele me pareceu bem interessante. Mas espera ai, qual é a proposta dele afinal?

Segundo o próprio site o Docker é uma plataforma aberta para aplicativos distribuídos para desenvolvedores e administradores de sistemas. Ele é uma abstração, que adiciona recursos e simplifica o uso dos linux containers (LXC), que são uma forma de isolamento de processos e sistemas, é quase uma virtualização, porém mais leve e integrada ao host. Linux-only. O Docker te permite criar pequenas aplicações chamadas de "containers", que isolam o Sistema Operacional base e toda a pilha de dependência de sua app de forma leve em espaço e consumo. Muitas pessoas dizem que ele é o Vagrant para produção pois são VMs muito leves, que podem rodar em cima de outras VMs. Imagina o seu uso? Podemos aplica-lo em diversas aplicações com ambientes diferentes (apache, nginx, tomcat...) em uma mesma maquina ou vm e sem perder muito em recursos.

Alem de resolver o nosso problema em ambientes dev/live ele tem mais(tipo vendedor hein). O Docker trabalha com um sistema de arquivos empilhaveis, que permite que os passos para configuração do container funcione de forma incremental. Tipo os o versionamento do git/mercurial. Então imagine o processo, atualizou uma lib: commit. Mudou a versão do php: commit, terminou uma nova versão: Tag. E depois de tudo isso é só dar um push, temos uma atualização compartilhada dentro das pessoas que participam do seu projeto ;) .

Ok, estou convencido o Docker é fóda! Como eu começo?

Antes de começar, o Docker é para Linux então, se vc não usa linux vai ter que virtualizar ;)

1º Instalando

No meu caso, eu estou usando o Ubuntu 14.04, então é mais do mesmo, instale o docker.io via apt-get e crie um link para usar docker, caso vc queira usar a ultima versão sempre de uma olhada aqui:

$ sudo apt-get update
$ sudo apt-get install docker.io
$ sudo ln -sf /usr/bin/docker.io /usr/local/bin/docker
$ sudo sed -i '$acomplete -F _docker docker' /etc/bash_completion.d/docker.io

2º Em seguida, adicione a chave do repositório Docker para o seu chaveiro local.

$ sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9

3º Agora adicione o repositório Docker ao seu sources list, atualize e instale o pacote lxc-docker

$ sudo sh -c "echo deb https://get.docker.io/ubuntu docker main\
> /etc/apt/sources.list.d/docker.list"
$ sudo apt-get update
$ sudo apt-get install lxc-docker

4º Adicioner seu usuario no grupo do docker

Assim vc nao vai precisar ficar fazendo sudo docker lalala.

sudo gpasswd -a myusername docker

5º Autentique-se no docker hub (se n tem conta crie uma aqui)

docker login

6º Suba um container do docker que eu fiz com php-fpm e nginx em sua maquina, a primeira vez que vc rodar esse command vai demorar um pouco pois será feito um pull da imagem.

docker run -v /var/www:/usr/share/nginx/www:rw --expose=80 --dns=127.0.0.1 -i -t pvgomes/php /bin/bash

Preste atenção em algumas coisas desse commando, primeira fazemo um docker run (executar o container) depois passamos um diretorio /var/www fazendo um link com /usr/share/nginx/www e dando premissão de leitura e escrita (rw), isso significa que vamos fazer um link de um path do container com a sua máquina (assim na configuração do nginx apontariamos para /share/nginx/www/seuprojeto), depois expomos a porta 80 e passamos o dns. Pronto vc tem um container do docker rodando :)

Meu objetivo nesse post foi apenas introduzir o Docker, no próximo vamos passar a utilizar o container de fato.

Valeu!

Processo de desenvolvimento de software de maneira simples

noreply@blogger.com (Anonymous) — Tue, 8 Apr 2014 18:00:00 -0300

Fala pessoal tudo bem? Hoje vou ser bem clássico pois vou falar de um assunto que envolve parte seu conhecimento universitário e parte o seu conhecimento na prática. Para aqueles que só tem a teoria eu recomendo a prática e para os analistas desenvolvedores da prática eu recomendo uma pausa para a leitura de hoje que é sobre o "processo de desenvolvimento de sofware".

Ok mas como eu defino o processo de desenvolvimento de software?

O processo de desenvolvimento de software é entre outras definições um conjunto de ações parcialmente ordenadas, com a finalidade de obter um sistema informatizado. Ele é estudado principalmente na área de Engenharia de Software, sendo considerado um dos principais mecanismos para a entrega de um sistema coeso que atenda as necessidades de seus usuários. A qualidade e velocidade para entregar um software é determinante dentro dos estudos da engenharia de software, mas não se engane ela não é uma métrica exata.

Dentro do processo do desenvolvimento de software existem diversas etapas e vou falar um pouquinho de cada uma que são:

1 - Análise de requisitos

2 - Especificação

3 - Arquitetura de Software

4 - Implementação

5 - Testes

OBS: Saiba que com o movimento ágil utilizando SCRUM e XP esse processo não necessáriamente é tão burocrático pois o manifésto agil prega a agilidade (Recomendo fortemente essa leitura aqui sobre o manifesto agil).

Ainda assim o processo clássico não será descartado e vamos mostrar suas responsabilidades.

1 - Análise de requisitos

Quando se trata do entendimento dos requisitos para um sistemas sendo uma parte importante do processo de projeto de sistemas, no qual o analista de negócio, aliado com outros participantes de software identificam as necessidade ou requisitos de um usuario.

Uma vez que os requisitos do sistema tenham sido identificados, os projetistas de sistema (entenda-se o carinha que vai pensar no business) estarão preparados para projetar a solução.

Existe a divisão de requisitos sendo Requisito funcional e Requisito não-funcional, esta parte do processo o analista faz as primeiras entrevistas com os clientes e/ou usuários do software para conhecer as funcionalidades do sistema que será desenvolvido. Mas atenção é aqui que acontece a maior parte dos erros, pois a falta de experiência dos clientes ou usuários faz com que eles nem sempre tenham claro em sua mente quais funcionalidades o software necessita.

A grande questão da analise de requisitos é: como como saber se as necessidades do domínio do sistema foi captada? O objetivo dessa fase é justamente levantar os requisitos e garantir o amadurecimento deles, gosto muito de adicionar o básico diagrama de classes da UML nessa fase pois pelo menos eu consigo ter algo "palpavel" rsrs. Pois bem já deu para perceber que essa fase é imprescindível não é? E depois disso como eu começo a pensar no meu "ecosistema"?.

2 - Especificação

A especificação é a definição do que se espera que um software faça. Ela pode ser informal, neste caso ela pode ser considerada como um blueprint ou manual de usuário do ponto de vista do desenvolvedor, ou formal, no caso de ela ser definida principalmente em termos matemáticos ou programáticos.

Na prática, as especificações mais bem sucedidas são escritas para a compreensão e ajustes em uma aplicação que já se encontra bem desenvolvida, embora sistemas de sistemas de segurança críticos sejam cuidadosamente especificados antes do desenvolvimento da aplicação. Especificações são mais importantes para interfaces externas que devem permanecer estáveis. Aqui na especificação é que acontece o tão "famoso" prototípo que costumam chamar de fase de prototipação, sinceramente não curto muito essa montagem "coxinha" da especificação pois na minha opinião usando UML e criando pequenos wireframes já conseguimos abordar muita coisa, e como eu disse antes as coisas devem ser feitas em pequenos trechos, imagine que vc vá desenvolver um e-commerce vão não vai especificar TUDO não é? melhor começarmos pelo catalogo, depois carrinho, logística do armazém e etc, assim garantimos mais exatidão na hora da entrega :D.

3 - Arquitetura de Software

A arquitetura de software é a fase que o desenvolvedor da as cartas, claro que se pensarmos no Domain Driven Design o desenvolvedor participa de TUDO, mas veja bem, é aqui que ele decide os componentes de software, sua regras básicas internas, suas propriedades externas, e seus relacionamentos com outros softwares. Essa fase tem como objetivo manter o sistema organizado no quesito estrutural e comportamental, garantindo que os dados tratados pelo software tenham comportamento coeso e definido, permitindo também mudanças lógicas sem afetar seu funcionamento. A arquitetura de software é necesserária para definir padrões e o design de uma aplicação, é aqui por exemplo que iriamos falar de Hexagonal Architecture, mas não vou falar sobre isso hoje pois eu me alongaria muito e tbm n tenho conhecimentos soloidos sobre isso rs.

Vou pegar um trecho que escrevi no segundo ano da faculdade sobre a arquitetura de software (que trabalho para copiar do caderno kkkkkk)
"O campo da ciência da computação tem lidado com problemas associados, como a complexidade da informação, desde sua criação. Os primeiros problemas de complexidade foram resolvidos pelos desenvolvedores através da escolha da estrutura de dados, do desenvolvimento de algoritmos e pela aplicação de conceitos de separação de escopos. Embora o termo arquitetura de software seja relativamente novo na indústria, os princípios fundamentais deste campo vêm sendo aplicados esporadicamente pela engenharia de software desde o início dos anos 80. As primeiras tentativas de capturar e explicar a arquitetura de software do sistema foram imprecisas e desorganizadas – freqüentemente caracterizadas por um conjunto de diagramas. Durante o decorrer da década de 90 houve um esforço concentrado para definir e codificar os aspectos fundamentais desta disciplina. Inicialmente um conjunto de padrões de projeto, estilo, melhores práticas, descrição de linguagens, e lógica formal foram desenvolvidas durante este período."

4 - Implementação

Analistas falem o que for essa é a parte mais PICA de todas, todo software é escrito em uma linguagem de programação, embora seja possível, com alguma dificuldade, escrevê-lo diretamente em linguagem de máquina. Diferentes partes de um programa podem ser escritas em diferentes linguagens, diferente do que o processo de software comum prega nessa fase também testamos o nosso código como prega o processo TDD

"TDD é o desenvolvimento de software orientado a testes. Entenda mais detalhes e como usá-lo! TDD é o desenvolvimento de software orientado a testes, ou em inglês, Test Driven Development. Mas mais do que simplesmente testar seu código, TDD é uma filosofia, uma cultura.".

Diferentes linguagens de programação funcionam de diferentes modos. Por esse motivo, os programadores podem criar programas muito diferentes para diferentes linguagens; muito embora, teoricamente, a maioria das linguagens possa ser usada para criar qualquer programa.

Há várias décadas se debate se a programação é mais semelhante a uma arte (Donald Knuth), a uma ciência, à matemática (Edsger Dijkstra), à engenharia (David Parnas), ou se é um campo completamente novo. Ao meu ver desenvolvimento é uma mescla de arte com engenharia mas isso é minha opinião.

Para alguma tecnologias OPEN SOURCE o desenvolvedor precisa fazer tudo, TUDO mesmo, subir ambiente, banco de dados, então eu acredito que essa fase precisa de MUITA mas muita atenção e cuidado.

5 - Testes

O teste de software é a maneira de verificar a qualidade do fotware em relação ao contexto em que ele deve operar. Isso inclui o processo de utilizar o produto para encontrar seus defeitos.

O teste é um processo realizado pelo testador de software, que abrange outros processos da engenharia de software, e que envolve ações que vão do levantamento de requisitos até a execução do teste propriamente dito.

Segundo a DEVMEDIA:

“Teste de software é o processo de execução de um produto para determinar se ele atingiu suas especificações e funcionou corretamente no ambiente p$paymentFormara o qual foi projetado. O seu objetivo é revelar falhas em um produto, para que as causas dessas falhas sejam identificadas e possam ser corrigidas pela equipe de desenvolvimento antes da entrega final. Por conta dessa característica das atividades de teste, dizemos que sua natureza é “destrutiva”, e não “construtiva”, pois visa ao aumento da confiança de um produto através da exposição de seus problemas, porém antes de sua entrega ao usuário final”

Existem alguns conceitos básicos associados ao teste de software que são: defeito, erro e falha.

A figura 1 expressa a diferença entre esses conceitos. Defeitos fazem parte do universo físico (a aplicação propriamente dita) e são causados por pessoas, por exemplo, através do mal uso de uma tecnologia. Defeitos podem ocasionar a manifestação de erros em um produto, ou seja, a construção de um software de forma diferente ao que foi especificado (universo de informação). Por fim, os erros geram falhas, que são comportamentos inesperados em um software que afetam diretamente o usuário final da aplicação (universo do usuário) e pode inviabilizar a utilização de um software.

Existem alguns conceitos bem conhecidos de teste que são;

A - Caixa Branca

Também chamada de teste estrutural ou orientado à lógica, a técnica de caixa-branca avalia o comportamento interno do componente de software. Essa técnica trabalha diretamente sobre o código fonte do componente de software para avaliar aspectos tais como: teste de condição, teste de fluxo de dados, teste de ciclos, teste de caminhos lógicos, códigos nunca executados.

Os aspectos avaliados nesta técnica de teste dependerão da complexidade e da tecnologia que determinarem a construção do componente de software, cabendo portanto avaliação de mais aspectos que os citados anteriormente. O testador tem acesso ao código fonte da aplicação e pode construir códigos para efetuar a ligação de bibliotecas e componentes. Este tipo de teste é desenvolvido analisando o código fonte e elaborando casos de teste que cubram todas as possibilidades do componente de software. Dessa maneira, todas as variações relevantes originadas por estruturas de condições são testadas.

Um exemplo bem prático desta técnica de teste é o uso da ferramenta livre JUnit para desenvolvimento de classes de teste para testar classes ou métodos desenvolvidos em Java. Também se enquadram nessa técnica testes manuais ou testes efetuados com apoio de ferramentas para verificação de aderência a boas práticas de codificação reconhecidas pelo mercado de software. A aderência a padrões e boas práticas visa principalmente a diminuição da possibilidade de erros de codificação e a busca de utilização de comandos que gerem o melhor desempenho de execução possível. Apesar de muitos desenvolvedores alegarem que não há ganhos perceptíveis com essa técnica de teste aplicada sobre unidades de software, devemos lembrar que, no ambiente produtivo, cada programa pode vir a ser executado milhares ou milhões de vezes em intervalos de tempo pequenos. É na realidade de produção que a soma dos aparentes pequenos tempos de execução e consumo de memória de cada programa poderá levar o software a deixar de atender aos objetivos esperados. A técnica de teste de caixa-branca é recomendada para as fases de teste de unidade e teste de integração, cuja responsabilidade principal fica a cargo dos desenvolvedores do software, que por sua vez conhecem bem o código fonte produzido.

B - Caixa Preta

Também chamada de teste funcional, orientado a dado ou orientado a entrada e saída, a técnica de caixa-preta avalia o comportamento externo do componente de software, sem se considerar o comportamento interno do mesmo.4 Dados de entrada são fornecidos, o teste é executado e o resultado obtido é comparado a um resultado esperado previamente conhecido. Como detalhes de implementação não são considerados, os casos de teste são todos derivados da especificação.

Quanto mais entradas são fornecidas, mais rico será o teste. Numa situação ideal todas as entradas possíveis seriam testadas, mas na ampla maioria dos casos isso é impossível. Outro problema é que a especificação pode estar ambígua em relação ao sistema produzido, e como resultado as entradas especificadas podem não ser as mesmas aceitas para o teste. Uma abordagem mais realista para o teste de caixa-preta é escolher um subconjunto de entradas que maximize a riqueza do teste. Pode-se agrupar subconjuntos de entradas possíveis que são processadas similarmente, de forma que testar somente um elemento desse subconjunto serve para averiguar a qualidade de todo o subconjunto. Por exemplo, em um sistema que aceita um inteiro como entrada, testar todos os casos possíveis pode gerar pelo menos dezenas de milhares de casos de testes distintos. Entretanto, a partir da especificação do sistema, pode-se encontrar um subconjunto de inteiros que maximizem a qualidade do teste. Depende do propósito do sistema, mas casos possíveis incluem inteiros pares, inteiros ímpares, zero, inteiros positivos, inteiros negativos, o maior inteiro, o menor inteiro.

Essa técnica é aplicável a todas as fases de teste – teste unitário, teste de integração, teste de sistema e teste de aceitação. A aplicação de técnicas de teste leva o testador a produzir um conjunto de casos de teste (ou situações de teste). A aplicação combinada de outra técnica – técnica de particionamento de equivalência (ou uso de classes de equivalência) permite avaliar se a quantidade de casos de teste produzida é coerente. A partir das classes de equivalência identificadas, o testador construirá casos de teste que atuem nos limites superiores e inferiores destas classes, de forma que um número mínimo de casos de teste permita a maior cobertura de teste possível.

Uma abordagem no desenvolvimento do teste de caixa-preta é o teste baseado na especificação, de forma que as funcionalidades são testadas de acordo com os requisitos. Apesar de necessário, esse tipo de teste é insuficiente para identificar certos riscos num projeto de software

C - Unitários

Fase em que se testam as menores unidades de software desenvolvidas (pequenas partes ou unidades do sistema). O universo alvo desse tipo de teste são as subrotinas ou mesmo pequenos trechos de código. Assim, o objetivo é o de encontrar falhas de funcionamento dentro de uma pequena parte do sistema funcionando independentemente do todo. Para as linguagens de programação mais sofisticadas existem os chamados frameworks xUnit, criados com o intuito de facilitar e padronizar os testes de unidade, normalmente o prefixo é substituido por alguma identificação da linguagem como por exemplo PhpUnit para PHP, jUnit para java, entre tantos outros, fornecem a estrutura para os testes e também podem criar métricas de cobertura de teste.

D - Teste de Integração

Na fase de teste de integração, o objetivo é encontrar falhas provenientes da integração interna dos componentes de um sistema. Geralmente os tipos de falhas encontradas são de transmissão de dados. Por exemplo, um componente A pode estar aguardando o retorno de um valor X ao executar um método do componente B; porém, B pode retornar um valor Y, gerando uma falha. Não faz parte do escopo dessa fase de teste o tratamento de interfaces com outros sistemas (integração entre sistemas). Essas interfaces são testadas na fase de teste de sistema, apesar de, a critério do gerente de projeto, estas interfaces podem ser testadas mesmo antes de o sistema estar plenamente construído.

E - Teste de Sistema

Na fase de teste de sistema, o objetivo é executar o sistema sob ponto de vista de seu usuário final, varrendo as funcionalidades em busca de falhas em relação aos objetivos originais. Os testes são executados em condições similares – de ambiente, interfaces sistêmicas e massas de dados – àquelas que um usuário utilizará no seu dia-a-dia de manipulação do sistema. De acordo com a política de uma organização, podem ser utilizadas condições reais de ambiente, interfaces sistêmicas e massas de dados.

F - Teste de Aceitação

Geralmente, os testes de aceitação são realizados por um grupo restrito de usuários finais do sistema, que simulam operações de rotina do sistema de modo a verificar se seu comportamento está de acordo com o solicitado. Teste formal conduzido para determinar se um sistema satisfaz ou não seus critérios de aceitação e para permitir ao cliente determinar se aceita ou não o sistema. Validação de um software pelo comprador, pelo usuário ou por terceira parte, com o uso de dados ou cenários especificados ou reais. Pode incluir testes funcionais, de configuração, de recuperação de falhas, de segurança e de desempenho.

Pois bem amiguinho, basicamente o desenvolvimento de software segue esses processos, dúvidas, sugestões ou críticas é só falar!

Seminário PHP: Show me The Code!

noreply@blogger.com (Anonymous) — Thu, 13 Mar 2014 08:50:00 -0300

Se alguém ainda acessa meu blog para acompanhar artigos sobre desenvolvimento aqui vai um convite para um evento em Porto Alegre - Rio Grande do Sul , sobre qualidade de software. O evento é promovido pela Tempo Real Eventos e tem o nome de "Show me The Code" e vai acontecer no dia 12 de abril de 2014.

Ontem (dia 12 de Março) fizemos um Hangout com alguns palestrantes falando sobre o evento, o video segue abaixo:

Zend Certified PHP 5.5

noreply@blogger.com (Anonymous) — Sat, 19 Oct 2013 08:18:00 -0300

Chega de suposições sobre a próxima certificação que a Zend vai lançar, no dia 03 de Outubro de 2013 a Zend deixou disponível através da Pearson VUE a sua mais nova certificação. PHP 5.5 a versão atual do PHP agora está disponível para quem quiser fazer a prova. Verifiquei nos tópicos que pouca coisa mudou, apenas foram adicionados os aspectos importantes do 5.4 E 5.5.

A prova ainda é dividida em 10 tópicos sendo eles:

PHP Basics	Functions	Data Format & Types
Syntax Operators Variables Control Structures Language Constructs and Functions Namespaces (5.3) * Extensions Config Performance/bytecode caching (5.3) *	Arguments Variables References Returns Variable Scope Anonymous Functions, closures (5.3) *	XML Basics SimpleXML XML Extension Webservices Basics SOAP JSON (5.3) * DateTime (5.3) * DOMDocument

Web Features

Object Oriented Programming

Security

Sessions
Forms
GET and POST data
Cookies
HTTP Headers
HTTP Authentication
HTTP Status Codes *

I/O

Files
Reading
Writing
File System Functions
Streams
Contexts

Instantiation
Modifiers/Inheritance
Interfaces
Exceptions
Autoload
Reflection
Type Hinting
Class Constants
Late Static Binding
Magic (_*) Methods
Instance Methods & Properties
SPL
Traits (5.4) *

Configuration
Session Security
Cross-Site Scripting
Cross-Site Request Forgeries
SQL Injection
Remote Code Injection
Email Injection
Filter Input
Escape Output
Encryption, Hashing algorithms
File uploads
PHP Configuration
Data Storage
SSL
Password hashing API (5.5)*

Strings & Patterns	Databases & SQL	Arrays
Quoting Matching Extracting Searching Replacing Formatting PCRE NOWDOC and HEREDOC Encodings	SQL Joins Analyzing Query Prepared Statements Transactions PDO	Enumerated Arrays Associative Arrays Array Iteration Array Functions SPL, Objects as arrays (5.3/5.4/ 5.5) * Casting

Bem por esse quadro nós percebemos claramente que foi adicionado o que é de fato importante, e a Zend tiou algumas coisas que não faz mais sentido estar no PHP 5.5 ou seja, se vc já estava estudando para a certificação continue o seu plano de estudos, continue fazendo os testes que encontrou e estude apenas as coisas novas em paralelo. Para essas novas funcionalidades vou indicar um blog de um cara que é fera e conceituadissimo na comunidade PHP que é o Thiago Belem e aqui esta o blog

http://blog.thiagobelem.net/

PHP 5.4, 5.5 Traits, Generators e outras coisas boas - Hands On

noreply@blogger.com (Anonymous) — Wed, 18 Sep 2013 07:33:00 -0300

Olá amigos e amigas, esse artigo é apenas para eu divulgar o Hands On que vou fazer sobre PHP 5.4 e PHP 5.5 , dessa vez ńão é apenas apresentação mas sim mão na massa de como e quando utilizar esses funcionalidades das novas versões.

Para se inscrever é só entrar aqui http://www.season.com.br/cms/treinamentos/calendario/detalhe/evento/447/ o custo de investimento é de R$ 140,00 para presencial, provavelmente vamos transmitir também mas eu ainda não sei ainda se os preços serão os mesmos, assim que eu conseguir informações eu informo.

Bem, nos vemos la!

Traits do PHP 5.4

noreply@blogger.com (Anonymous) — Sat, 7 Sep 2013 20:51:00 -0300

Bem amigos(as) hoje vou falar finalmente das TRAITS adicionadas no PHP 5.4, é verdade que já faz um ano que lançaram o PHP 5.4 e eu sempre quis falar rápido sobre as poderosas traits mas sempre fiquei enrolando então, agora é a hora.

Afinal, o que são Traits? Traits são mecanismos que ajudam o problema de multipla extensão auxiliando de forma elegante o reuso de código. Essa é basicamente a explicação da documentação mas a minha visão sobre Traits é que além de facilitar o reuso do código elas ajudam e muito uma arquitetura melhor da sua aplicação PHP e vocês vão ver pq eu acho isso.

Vamos imaginar uma situação real, vc está desenvolvendo um portal de notícias e toda interação dos usuários no site (Autenticação, comentário em notícia, adicionar agenda, comprar ingressos para show, etc...) precisamos registrar em uma funcionalidade que grava o comportamento do usuário nesse site, não sendo necessáriamente um log mas sim uma funcionalidade para traçar perfil.

Vamos imaginar o básico da classe de usuario e da classe de traçar perfil(vamos chamar ela de perfil apenas para estudo certo?)

Classe PERFIL RESPONSÁVEL PARA REGISTRAR E TRAÇAR PERFIL DE AÇÕES

<?php

class Perfil{    

    public function registra($acao){

        //registra uma ação

    }

}

E ai a nossa de usuario com uma pequena ação de alterar foto

Classe PESSOA

  

<?php

class Pessoa extends AppEntityPessoa{

    private $nome;    

    /**

     * Getters and setters

     */        

    public function alteraFoto($acao){

        //faz algo...

        // preciso registrar a acao na perfil como tornar isso um comportamento desse contexto?

    }

}

Legal agora temos um problema que deve ser tratado seriamente como um padrão de arquitetura, se por obrigação todas minhas classes que representem dados precisam estender de uma entity da aplicação(vamos imaginar que essa é a estrutura imaginada), como eu soluciono esse problema? Existem diversas formas, mas as mais utilizadas seriam duas, a primeira seria criar uma estrutura de heranças em que em uma parte dela teriamos a classe perfil e essa por questões obvias é muito feia e sem sentido, mas ainda assim é uma solução utilizada. A segunda solução e mais recomendade seria no construtor da classe pessoa eu instânciar a classe Perfil e ai eu teria a instância injetada nessa classe utilizando esse contexto facilmente.

Pois bem apesar de uma solução melhor ainda assim não e boa e as traits resolvem isso mesmo, utilizando essa solução em traits criariamos a classe perfil como uma trait e apenas usariamos nas classes que julgamos necessário basicamente assim:

TRAIT PERFIL RESOLVENDO NOSSO PROBLEMA

<?php

trait Perfil{    

    public function registra($acao){

        //registra uma ação

    }

E ai a classe pessoa utilizaria a trait com o use dentro da classe, herdando assim as características dela sem precisar instancia-la:

UTILIZANDO A TRAIT PERFIL

<?php

class Pessoa extends Perfil{

    use Perfil;

    private $nome;    

    /**

     * Getters and setters

     */        

    public function alteraFoto($acao){

        //faz algo

        $this->registra($acao);

    }

}

Conclusão

Traits resolvem de fato um problema de arquitetura sendo mais fácil pensar em como consumir classes fóra de contexto sem instancia-las ou herdar elas criando uma estrutura maluca. Frameworks vão utilizar isso com muita felicidade pois essa funcionalidade acaba com uma porrada de hierarquias gigantes criadas anteriormente.

Bem... é isso.

Referência: Documentação Oficial http://br1.php.net/manual/en/language.oop5.traits.php

Encontro PHP dia 06/08 19:30 em SP

noreply@blogger.com (Anonymous) — Sun, 4 Aug 2013 10:55:00 -0300

Buenas! Esse artigo é somente para compartilhar o encontro PHP realizado pela Season onde vamos ter muito networking e compartilhamento de conhecimento. O encontro acontece dia 06/08/2013 (terça-feira) ás 19:30 na Avenida Bernadino de Campos, nº 327 CJ 92, Bairro Paraíso - São Paulo - SP

Esse evento conta com duas palestras, sendo uma minha que vou falar sobre Domain-Driven Design aplicado no PHP e outra do Anderson Casimiro (Duodraco) que vai falar sobre Excelência em Software.

Se inscreva e participe, a inscrição é gratuita! Agora se você não puder ir se inscreve e assista via WEBCAST nesse link:
https://docs.google.com/spreadsheet/viewform?formkey=dEttMGpLNlVXQlQzSXRFUWxsb043ZUE6MA

Instalando o OpenJDK 7 no Ubuntu 13.04

noreply@blogger.com (Anonymous) — Sat, 27 Jul 2013 07:51:00 -0300

Olá amigos, essa é para vc que precisa do OpenJDK 7 para acessar seu internet banking ou instalar netbeans subir o solr ou coisas derivadas que precisam do java. Vamos instalar o Open JDK 7 no ubuntu 13.04

Primeiro vamos instalar o IcedTea plugin para o navegador

$ sudo apt-get install icedtea-7-plugin openjdk-7-jre

Agora O openjdk

$ sudo apt-get install openjdk-7-jdk

Bem, é isso ae.

Nginx php-fpm e mysql e phpmyadmin no Ubuntu 13.04

noreply@blogger.com (Anonymous) — Wed, 12 Jun 2013 00:03:00 -0300

Olá amigos e amigas tudo bem? Hoje vou mostrar aqui de maneira bem objetiva como montar um ambiente padrão com o todo poderoso Nginx utilizando php-fpm e de quebra mysql no Ubuntu 13.04 ok?

No final deste pequeno artigo teremos um phpmyadmin rodando legalzinho com o nginx.

Abra o seu console e siga os passos(preciso dizer que precisa rodar como root?).

1º Vamos começar com nosso querido mysql
apt-get install mysql-client-5.5 mysql-server-5.5 php5-mysql

1º Agora o PHP
apt-get install php5 php5-cli php5-dev php5-mcrypt php5-curl php5-gd libapache2-mod-php5

2º Agora o Nginx
apt-get install nginx

3º Restart no nginx

/etc/init.d/nginx restart

4º Instalando o php-fpm
apt-get install php5-fpm

5º Vamos criar o diretorio www no /var para deixar la nossos fontes (vc não precisa fazer isso pode utilizar outro lugar, mas eu gosto deste)

mkdir /var/www

Agora vamos baixar os fontes do phpmyadmin em http://www.phpmyadmin.net/ estou utilizando a versão 4.0.3

Terminando o download vamos descompactar nosso amiguinho

unzip phpMyAdmin-4.0.3-all-languages.zip

E mover ele para o diretorio /var/www com o nome somente de phpMyAdmin
mv phpMyAdmin-4.0.3-all-languages /var/www/phpMyAdmin

Pronto. Agora vamos configurar os hosts do nosso phpMyAdmin

Criando a linha no hosts

vim /etc/hosts

Adicione
127.0.0.1 phpmyadmin.dev

E agora vamos criar o arquivo de configuração do nginx

vim /etc/nginx/sites-available/phpmyadmin.dev

E ai vc insere esse conteudo:

### phpmyadmin simple configuration

server {

server_name phpmyadmin.dev;

access_log  /var/log/nginx/phpmyadmin.access.log;

error_log   /var/log/nginx/phpmyadmin.error.log; 

client_max_body_size  5m;

client_header_timeout 1200;

client_body_timeout   1200;

send_timeout          1200;

keepalive_timeout     1200;

set $thttps off;

root        /var/www/phpMyAdmin/;

try_files   $uri $uri/ /index.php?$args;

index       index.php;

location ~ \.php$ {

fastcgi_pass    127.0.0.1:9000;

fastcgi_index   index.php;

include         fastcgi_params;

fastcgi_connect_timeout 1200;

fastcgi_send_timeout    1200;

fastcgi_read_timeout    1200;

fastcgi_param   SCRIPT_FILENAME $document_root$fastcgi_script_name;

fastcgi_param   APPLICATION_ENV dev;

}

error_page  403 /403.html;

error_page  404 /404.html;

error_page  500 502 503 504 /50x.html;

}

Cria um link maroto para o sites-enable
ln -s /etc/nginx/sites-available/phpmyadmin.dev /etc/nginx/sites-enabled/phpmyadmin.dev

por fim vamos arrumar a porta de escuta no fpm
sudo vim /etc/php5/fpm/pool.d/www.conf

procura a linha que esta assim:
listen = /var/run/php5-fpm.sock

e mude para
listen = 127.0.0.1:9000

(lembre-se que no arquivo de conf colocamos o fast na 9000)

E da um restart na parada toda
service php5-fpm restart
/etc/init.d/nginx restart

e ai é só acessar
http://phpmyadmin.dev

Done!

Dúvidas não exite em perguntar.

TDC2013

noreply@blogger.com (Anonymous) — Sat, 1 Jun 2013 16:29:00 -0300

De 10 a 14 de Julho o TDC está de volta meus amigos! Vamos todos para o TDC2013 São Paulo

ZF1 para ZF2

noreply@blogger.com (Anonymous) — Mon, 27 May 2013 21:15:00 -0300

Olá amigos(as), hoje vou apenas compartilhar aqui o video que foi o primeiro Webinar oficial da Zend feito em português pelo já conhecido e famoso Flávio Gomes Lisboa (Escritor dos livros de ZF1). Eu tive a oportunidade de assistir a transmissão ao vivo e achei muito produtiva em todos os aspectos.

Acho que o video tenta de uma forma simples comparar as diferenças entre os dois frameworks e mostrar os desafios que a Zend passou para criar esse framework tão robusto que é o Zend Framework 2.

Sendo assim segue abaixo o link do video:

http://www.zend.com/en/webinar/ZF/70170000000c4Mm-migrando-do-zf1-para-o-zf2-20130416.flv

Netflix no Linux Ubuntu

noreply@blogger.com (Anonymous) — Tue, 30 Apr 2013 19:16:00 -0300

Esse pequeno artigo vai te ajudar rapidamente a rodar o Netflix no Linux Ubuntu.

Mas espera ai! O NETFLIX NÃO RODA NO LINUX? E A RESPOSTA É SIMPLES, O NETFLIX utiliza o Microsoft Silverlight....

Na boa, há um ano atrás eu vi algumas estratégias do NETFLIX sobre uso do HTML5 muito interessantes, e até imaginei que fosse uma empresa "estilo Google de pensar", mas depois que eu vi que além de utilizarem Silverlight não existe uma alternativa criada POR ELES DIRETO NO BROWSER achei uma baita palhaçada e descaso dessa empresa.
Sério, que ano eles pensam que estão? Será que é tudo da Microsoft? Será que a Microsoft ainda não aprendeu que quando vc tenta impor algo vc só tem a perder? Sei lá viu, algumas pessoas e alguns cargos na área de TI não deveriam simplesmente existir.

Enfim, deixando o desabafo de lado vamos falar da solução técnica para isso, um programador do EUA chamado Erich E. Hoover também ficou puto mas não apenas reclamou como arregaçou as mangas e foi desenvolver uma solução(PARA NOOOOOSSSAAA ALEGRIAA), e é bemmm simples pois é basicamente o programa que trabalha com o Wine em conjunto com o Firefox. E para vc e eu que queremos fazer o Netflix rodar sem muito esforço ficou perfeito(rs).

Abra o terminal e resolva isso com 3 comandinhos$ sudo apt-add-repository ppa:ehoover/compholio
$ sudo apt-get update
$ sudo apt-get install netflix-desktop

Depois de instalado é só chamar nosso amiguinho e pronto
$ netflix-desktop

Fonte http://www.compholio.com/netflix-desktop/

Arquitetura SOLID

noreply@blogger.com (Anonymous) — Sat, 20 Apr 2013 09:07:00 -0300

Olá amigos, ultimamente ando com artigos mais conceituais pois meu intuito ultimamente é flexionar nosso cérebro para pensar de uma forma mais ampla do desenvolvimento de software. Por isso hoje vou falar da consagrada Arquitetura de Software SOLID

Em meados de 2005, Robert Martin(Uncle Bob), publicou um artigo sobre 11 princípios de Design para desenvolvimento Orientado a Objetos. No artigo ele diz que não basta programar orientado a objetos, é necessário ter princípios de design para manter a qualidade. Os 5 primeiros princípios ficaram “mais famosos”, sendo estes os que formam o S.O.L.I.D.

O SOLID tenta mostrar de maneira simples como planejar algo limpo e de uso altamente flexível(afinal, pq usar?). Vou dar uma acordada em vc ai, sabia que o famoso Zend Framework 2 usa SOLID? Pois é meu amigo e amiga o Matthew Weier cabeça do desenvolvimento do ZF2 buscou usar o melhor da atualidade para o framework e eles encontraram no SOLID uma forma de expressar o que eles queriam de fato que é o conceito de framework "USE O QUE VC QUISER E A VONTADE". Ta mais vamos ao ponto desse nome, veja a figura acima e acompanhe a explicação das siglas abaixo.

S – Single Responsibility principle: uma classe deve ter apenas uma responsabilidade.

O – Open/Closed principle: entidades de software devem ser abertos para extensão, mas fechadas para modificação.

L – Liskov substitution principle: objetos em um programa devem ser substitíveis por suas classes derivadas em qualquer ponto do código sem alterar a funcionalidade do programa.

I – Interface segregation principle: interfaces muito específicas são melhores do que interfaces de uso geral.

D – Dependency inversion principle: módulos devem depender de abstrações.

Mais detalhes, clique aqui.

Bem é basicamente isso recomendo uma leitura na documentação do Zend Framework 2(aqui) e também na matéria do Bob(aqui)

Entenda o Domain Driven Design

noreply@blogger.com (Anonymous) — Tue, 19 Mar 2013 07:08:00 -0300

Olá amigos e amigas tudo bem? Hoje vou resumir de uma forma mais "Mamão com açucar" O que é o DDD e imaginar exemplos utilizando o DDD para como resolver um determinado problema ok?

Provavelmente vc se lembra daqueles 3 gordinhos da Embratel não é? "pegue o seu d d dedo e disque o nu número da embratel, antes do ddd é 021..." Pois bem, eles não tem nada haver com o que eu vou explicar, mas fica ai como imagem de apresentação.

Existem duas maneiras de vc ter caído aqui no meu blog, a 1ª é vc conhecer meu blog e veio aqui para ver novos artigos(a grande menoria). A 2ª é pq vc está pesquisando sobre DDD e encontra muito artigo cheio de filosofia e acaba não absorvendo muito bem, e provavelmente vc não tem muito tempo para lêr o livro do Evans então chegas mais que vou resumir essa parada pra vc!

Antes de mais nada vamos ao entendimento básico, Domain Driven Design significa entre outras palavras Projeto Orientado a Domínio. Que veio do título do livro do Eric Evans. O livro do Evans é basicamente um catálogo de padrões baseados em experiências do próprio Evans ao longo de mais de 20 anos de desenvolvimento de software utilizando técnicas de Orientação a Objetos.

O DDD é basicamente o uso ideal da Orientação a Objetos(PRONTO ACABEI DE EXPLICAR TUDO PODE IR EMBORA).

Não fique bravo(a) comigo pois essencialmente é isso mesmo, DDD é o uso inteligente da orientação a objetos para resolver diversos problemas.

Vamos lá open your mind.

Os decoradores(entende-se pessoas que decoram) de Orientação a Objetos tem um problema grave com isso pois quando se fala em OO as primeiras coisas que vem na mente são "classes, herança, polimorfismo, encapsulamento, lalala...". Mas essa são as regras básicas e técnicas da OO, a grande sacada dela está em independência de tecnologia, mínimo de acoplamento, reutilização de código, alinhamento do código com o negócio, coerência em problemas reais... Olha só, agora sim estamos falando de OO resolvendo problemas reais e essa é a essencia campeonato(entende-se campeão).

Vamos ter um papo sério sem muita filosofia esse não é um artigo é mais uma conversa ok? Então vamos pensar, o Projeto Orientado a Domínio é essencialmente entendermos o negócio e tornar o código lógico a esse negócio, coeso a esse negócio, aquele papo de entity não pode ter lógica é justamente o OPOSTO do DDD pois sim vamos ter uma camada de domínio cujo qual minhas entidades são inteligentes! Separar a lógica em serviços que manipulam as entidades muitas vezes torna o reuso impossivel e é basicamente dizer eu sou um macaco que batuco o teclado com a intenção de gerar código....

O DDD não vai exatamente te impor como vc faz a arquitetura do seu software mas sim te abrir a mente sobre como dar funções para quem realmente merece afinal, vc não mandaria um engenheiro fazer uma cirurgia plástica não é?

Veja um exemplo do DDD por "cima":

Interface de Usuário – parte responsável pela exibição de informações do sistema ao usuário e também por interpretar comandos do usuário;

Aplicação – essa camada não possui lógica de negócio. Ela é apenas uma camada fina, responsável por conectar a Interface de Usuário às camadas inferiores;

Domínio – representa os conceitos, regras e lógicas de negócio. Todo o foco de DDD está nessa camada. Nosso trabalho, daqui para frente, será aperfeiçoar e compreender profundamente essa parte;

Infra-estrutura – fornece recursos técnicos que darão suporte às camadas superiores. São normalmente as partes de um sistema responsáveis por persistência de dados, conexões com bancos de dados, envio de mensagens por redes, gravação e leitura de discos, etc.

O DDD basicamente começa por essa premissa básica de conhecer de fato o domínio, mas ele é muito mais amplo e mais complexo por isso eu tentei aqui dar a introdução desse mundo partindo do principio de entender essa ideia.

Existem alguns pontos importantes abordados no DDD que são o uso da mesma linguagem, evitar traduções indevidas, quebrar o problema em camadas, entender entidades, agregados, objetos de valor, fábricas, serviços, repositórios, módulos entre outros.

Segue aqui a primeira versão de um slide da minha palestra sobre Domain Driven Design

Domain Driven Design no PHP from Paulo Victor Gomes

Caso vc queira se aprofundar nos estudos então é melhor ler o livro do Evans http://www.informit.com/store/domain-driven-design-tackling-complexity-in-the-heart-9780321125217

Até a próxima.

Testando suas classes com PHPUnit

noreply@blogger.com (Anonymous) — Thu, 28 Feb 2013 09:05:00 -0300

Hoje vou replicar um post do meu irmão(http://developer-v.blogspot.com.br), sim meu irmão também tem um blog e ele é da minha area.

Hy, folks!!!
E ai galera, finalmente vamos fazer um post, mão-na-massa, o que seria isso ???

????????????????????????

Simples um teste em classes, vamos usar agora o PHPunit para fazer um teste que ira funcionar realmente.

O que é Unit Testing?

- Testes para pequenos trechos de código (unidades)
- Verifica se o comportamento de classes e funções é o esperado
- Caso erros são encontrados exceções são lançadas
- Não interfere com o seu código-fonte

Qual a vantagem?

- Os testes são automatizados
- Eles são executados continuamente durante o ciclo de desenvolvimento
- Detectam falhas tanto de digitação e lógica e também comportamentos inesperados

Exemplo

class Classe1
{
public function somar($a, $b)
{
return $a+$b;
}
public function subtrair($a, $b)
{
return $a-$b;
}
}
// Teste da classe
$foo = new Classe1();
$soma = $foo->somar(2, 2);
$subracao = $foo->subtrair(2, 2);
echo '2 mais 2 = ' . $soma;
echo '2 menos 2 = ' . $subtracao;
// Funciona conforme esperado!

Apesar do exemplo simples, ilutra uma prática bem comum: a de inserir vários echo() e print() para confirmar o funcionamento de uma classe ou função.

O PHPUnit é uma framework que tem como objetivo automatizar e padronizar a forma como nosso código é testado.

"Whenever you are tempted to type something into a print statement or a debugger expression, write it as a test instead." -- Martin Fowler

Ou seja: "Toda vez que sentir vontade de escrever um print ou outra expressão de debug, pare e crie um teste!"

// Especifique o caminho do PHPUnit
require_once '/usr/share/php/PHPUnit/Framework.php';
// Especifique o caminho da classe a ser testada
require_once 'Classe1.php';
// Como a classe a ser testada se chama "Classe1", a classe de teste deverá se chamar "ClasseTest" e (neste caso) irá herdar de PHPUnit_Framework_TestCase
class Classe1Test extends PHPUnit_Framework_TestCase
{
// Funções de teste devem ter o prefixo "test"
public function testSoma()
{
// A classe a ser testada é instanciada
$foo = new Classe1();
// Testamos a afirmação que "4" é o resultado de passar "2" e "2" (ou seja, 2 + 2 = 4)
$this->assertEquals('4', $foo->somar(2, 2));
}
public function testSubtracao()
{
// idem (veja função acima)
$foo = new Classe1();
$this->assertEquals('0', $foo->subtrair(2, 2));
}
}

O resultado:

PHPUnit 3.3.16 by Sebastian Bergmann.
.
Time: 0 seconds
OK (2 tests, 2 assertions)
// Funciona conforme esperado!

O que aconteceu?
Criamos uma classe (Classe1Test) de teste para testar a nossa classe (Classe1) e usamos o PHPUnit para testar o funcionamento esperado

Não é mais complicado?
- Sim e não! Inicialmente pode parecer bem mais simples inserir alguns print() ou echo() e verificar manaulmente, mas ao longo prazo usar o PHPUnit traz diversas vantagens:
- Os testes ficam separados do código, assim não corremos o risco de esqueçer testes no meio do código. Devido à separação também não é necessário ficar voltando e comentando e descomentando as linhas de teste inseridas manualmente.
- Para aplicações um pouco mais complexas (por exemplo com várias classes interagindo juntas ou com AJAX) as vezes não é possível colocar echo() ou print() em qualquer lugar. Até mesmo o FirePHP gera erros de 'header'!
- Usando o PHPUnit criamos vários testes e sempre que desejarmos podemos rodá-los novamente para testar modificações.
- E o melhor de tudo, não precisamos fazer nada na hora de colocar a aplicação no ar. Simplesmente não fazemos o upload da pasta de testes! O código-fonte original segue intacto.

Como funciona?
- Crie uma classe de teste para testar uma classe já existente
- Excute os testes no terminal (ou prompt de comando) e veja os resultados
- A melhor maneira da aprender isto é através de exemplos então vamos instalar o PHPUnit e criar alguns testes!

Instalação do PHPUnit

Quem usa o linux pode fazer facilmente:

# se não tiver o PEAR instalado
apt-get install pear
# descubra o canal do PHPUnit
pear channel-discover pear.phpunit.de
# instale o phpunit
pear install phpunit/PHPUnit
# Ele fica instalado por padrão no /usr/share/php/PHPUnit
# Agora é só incluir o framework nos arquivos de teste e começar!

Quem usa windows procure no google! Não deve ser muito complicado... (se não me engano ele já vem incluso no pacote XAMPP)

Guia para criar Unit Tests

- Os testes para a classe "Classe1" (Classe1.php) deverão ser localizados dentro da classe "Classe1Test" (Classe1Test.php), sempre use o sufixo "Test" (NomeDaClasseTest)
- Na maioria dos casos a classe de teste irá herdar (extends) da classe PHPUnit_Framework_TestCase
- Os testes deverão ser funções públicas com o prefixo "test" (testSomar, testSubtrair, etc)
- Os testes são baseados em afirmações, ou seja: afirmamos que o resultado esperado da função X é Y, e testamos a afirmação pra ver se ela procede.
- Usamos funções como assertEquals() para testar afirmações (exemplos a seguir)

Algumas Afirmações disponíveis (Funções de Teste)

- Existem dezenas (veja a documentação http://www.phpunit.de/manual/), seguem algumas das mais comuns:
- assertEquals($valor, funcao()) (afirma que o valor retornado da funcao é igual a $valor)
- assertNotEquals($valor, funcao()) (afirma que o valor retornado da funcao não é igual a $valor)
- assertSame($valor, funcao()) (testa se o objeto retornado é igual a $valor)
- assertTrue(funcao()) (afirma que o valor retornado é === true)
- assertFalse(funcao()) (=== false)
- setExpectedException (avisa sobre uma exceção que deverá ser lançada)

Como rodar os testes

Através do terminal (ou prompt de comando), no diretório do arquivo de teste digite:

phpunit NomeDaClasseTest
# para rodar os testes contidos no arquivo NomeDaClasseTest.php

Vamos ver alguns exemplos na próxima página.
O test seguinte usa a função assertEquals() para checar o retorno de um método:

// Especifique o caminho do PHPUnit
require_once '/usr/share/php/PHPUnit/Framework.php';
// Especifique o caminho da classe a ser testada
require_once 'Classe2.php';
class Classe2Test extends PHPUnit_Framework_TestCase
{
public function testCumprimentarSemParametro()
{
// O comportamento esperado é que retorne "Olá fulano", testa esta afirmação
$this->assertEquals('Olá fulano', $foo->cumprimentar());
}
public function testCumprimentarComParametro()
{
// Instancia a classe e passa "Alex" ao construtor
$foo = new Classe2('Alex');
// O comportamento esperado é que retorne "Olá Alex", testa esta afirmação
$this->assertEquals('Olá Alex', $foo->cumprimentar());
}
// Funções de teste também podem ser identificados pela anotação @test no DocBlock
/**
* @test
*/
public function vaiDarErrado()
{
// Instancia a classe e passa "ciclano" ao construtor
$foo = new Classe2('ciclano');
// O comportamento esperado é que retorne "Olá ciclano", mas vamos afirmar que retornará outro valor para forçar um erro
$this->assertEquals('Olá Alex', $foo->cumprimentar());
}
}

Outro teste simples que retorna o seguinte:

PHPUnit 3.3.16 by Sebastian Bergmann.
..F
Time: 0 seconds
There was 1 failure:
1) vaiDarErrado(Classe2Test)
Failed asserting that two strings are equal.
expected string <Olá Alex>
difference < xxxx???>
got string <Olá ciclano>
/caminho/para/o/arquivo/Classe2Test.php:35
FAILURES!
Tests: 3, Assertions: 3, Failures: 1.

Ou seja, quando um teste falha ele informa o arquivo e linha onde ocorreu o erro.
Explica também qual foi o erro:
- O valor esperado era "Ola Alex"
- O valor retornado foi "Ola ciclano"
E ele ainda mostra a diferença ( xxxx???)

Fornecendo valores para os testes

- As vezes não basta só um teste com um valor estático
- Podemos criar uma função para alimentar o teste usando vários valores (e nada impede que sejam de fontes externas)
- A função é identificada através da anotação @dataProvider no DocBlock

Exemplo:
Uma versão um pouco mais complicada para explicar o uso do data provider em testes:

// Demonstração de "Data Providers"
class Classe3Test extends PHPUnit_Framework_TestCase
{
// Informa o nome do forneçedor de dados (@dataProvider) para a clase de teste
/**
* @dataProvider provider
*/
// Recebe 3 parâmetros
public function testCombine($a, $b, $c)
{
// Afirma que o valor do terceiro parâmetro é igual a concatenação dos primeiros dois separados por um espaço
$this->assertEquals($c, $a . ' ' . $b);
}
// A função fornecedora de valores
public function provider()
{
// retorna um array contendo 3 grupos de valores a serem testados
return array(
array('Hello', 'World', 'Hello World'),
array('É', 'Nois', 'É Nois'),
array('Deu', 'Errado', 'Deu Certo')
);
}
}

Valor retornado:

PHPUnit 3.3.16 by Sebastian Bergmann.
..F
Time: 0 seconds
There was 1 failure:
1) testCombine(Classe3Test) with data set #2 ('Deu', 'Errado', 'Deu Certo')
Failed asserting that two strings are equal.
expected string <Deu Certo>
difference < xxxxx?>
got string <Deu Errado>
/home/alex/Documents/aw/Articles/PHPUnit/Classe3Test.php:16
FAILURES!
Tests: 3, Assertions: 3, Failures: 1.

Resumindo...

- O assunto é bastante extenso e realmente fica difícil cobrir todas as possibilidades (que são quase infinitas)
- É possível criar testes para testar se Exceções são lançadas conforme esperado, para testar classes de acesso ao banco de dados e muito mais
- O ideal seria implementar isto em uma aplicação que esteja desenvolvendo, ou seja, crie uma pasta para os testes e vá criando testes para as suas classes nela

Todo o código-fonte para os exemplos e outros exemplos mais complexos (todos bem documentados) estão disponíveis:

Espero que tenham gostado e que eu tenha introduzido bem este assunto que é frequentemente subestimado e importantíssimo quande se trata de desenvolvimento.

Este post, foi melhorado para uma linguagem mais visual e facíl de entender =D...
Fonte PHPbr

Zipando arquivos com Zend Framework

noreply@blogger.com (Anonymous) — Fri, 18 Jan 2013 16:25:00 -0200

Hoje vou explicar como podemos comprimir arquivos em .zip utilizando a classe Zend_Filter_Compress_Zip do Zend Framework.

Versão do meu Zend Framework: 1.12 (a ultima versão antes do ZF2)

O problema
Algumas vezes precisamos gerar uma coleção de arquivos e comprimi-los em um unico lugar para efetivar o download ao usuario. Esse problema pode ser facilmente resolvido com as classes de ZIP do PHP mas é muito melhor utilizar uma classe util do Zend Framework que agiliza todo o seu tempo de desenvolvimento além de ter maior rigor nessa compressão. Ta mas e ai, como faço para utilizar essa Zend_Filter_Compress_Zip ?

O uso é bem simples veja:

USO DA Zend_Filter_Compress_Zip

/**

* @Desc Exemplo simples de compressão de arquivos

*/

public function exemplozipAction()

   $zip = new Zend_Filter_Compress_Zip();  

   /* O SEU ZIP COM O PATH E NOME */

   $zip->setArchive("/conteudo/exemplo.zip");

   /* O DESTINO */

   $zip->setTarget("/conteudo/");

   /* O ARQUIVO OU PASTA COM OS ARQUIVOS QUE SERÃO COMPRIMIDOS */

   $arquivoZipado = $zip->compress("/conteudo/tmp/");

   $this->view->arquivoZipado = $arquivoZipado;

}

Basicamente o que fazemos ai é, criar o objeto $zip da Zend_Filter_Compress_Zip definir o arquivo zip que será gerado, definir o destino e passar o arquivo ou o diretorio a ser comprimido(Todos os arquivos dentro do diretório serão comprimidos).
Depois é só mandar para download.

Simples não é? Veja que fiz esse artigo essencialmente para deixar claro que se vc utiliza o Zend Framework é bom que aproveite tudo que ele tem e não apenas a estrutura básica.

É ISSO AI, ATÉ A PRÓXIMA!

Descompilando

noreply@blogger.com (Anonymous) — Fri, 11 Jan 2013 13:29:00 -0200

Olá pessoas tudo bem?

Faz um tempo que não escrevo nada no blog isso acontece por muitos motivos mas o principal é que não ando muito inspirado e concentrado. Esse artigo é apenas para divulgar a união de blogs com meus amigos de desenvolvimento que acabou gerando a criação de um unico site onde vamos inserir nossos artigos.

O nome do site é "Descompilando" e o site é o descompilando.com.br para facilitar nossas vidas importamos todos os artigos dos blogs existentes e a partir dai começamos a escrever novos artigos. Não vou largar meu blog pois todo artigo que eu escrever la eu escrevo aqui(imaginamos então que eu não ando escrevendo nada nos dois blogs).
Bem é isso ando tão sem criatividade que até para falar nada eu falo nada.

Annotations no Doctrine - @Column

noreply@blogger.com (Anonymous) — Tue, 20 Nov 2012 09:28:00 -0200

Nesse post vou falar um pouco sobre as Annotations no Doctrine buscando deixar essa página como guia de consulta rápida para vc escrever suas entidades ok?

O que vc precisa saber para entender esse artigo:

Lógica de programação
PHP
POO
ORM
Conhecer pelo menos o básico de Doctrine

Bem, o que são essas annotations? Para quem conhece Java sabe que é indiscutível a agilidade e facilidade de configuração que as annotations proporcionam, elas são formas de descrever toda uma classe através de comentários.

Com o objetivo de trazer tal comodidade ao PHP surgiu o projeto Addendum – escrito por Jan Suchal – que permite via Reflection acessar as annotations das classes.

As annotations devem ser escritas em blocos de comentários, uma vez que o @ (caracter que inicia uma annotation) é um caractere reservado no PHP. Elas podem ser mono ou multi valoradas de acordo com os exemplos abaixo.

// Custom annotation  

class Persistent extends Annotation {}  

// Custom annotation  

class Table extends Annotation {}  

// Multi valued annotation  

class Secured extends Annotation {  

   public $role;  

   public $level;  

}  

/**  

 * @Persistent  

 * @Table("people")

 * @Secured(role = "admin", level = 2)

 */  

class Person {  

   // some code  

}  

// getting the annotation by class name  

$reflection = new ReflectionAnnotatedClass('Person');  

// getting the annotation by instance  

$person = new Person();  

$reflection = new ReflectionAnnotatedClass($person);  

// true  

$reflection->hasAnnotation('Persistent');  

// contains string "people"  

$reflection->getAnnotation('Table')->value;

No doctrine usamos as annotations para descrever uma classe que representa uma entidade do sistema ou seja, uma tabela no banco, seguindo a mesma onda da JPA, facilitando a configuração das classes de persistência e seus relacionamentos.

/**

 * @DoctrineEntity(tableName="pessoa")

 */  

class Pessoa {  

   /**

    * @DoctrineId

    * @DoctrineColumn(type="integer")

    * @DoctrineIdGenerator("auto")

    */  

   public $id;  

   /**

    * @DoctrineColumn(type="varchar", length=255)

    */  

   public $nome;  

   /**

    * @DoctrineColumn(type="varchar")

    */  

   public $sobrenome;  

   /**

    * @DoctrineManyToOne(targetEntity="Usuario",

           joinColumns={"user_id" = "id"})

    */  

   public $usuario;  

}

Vejam que acabamos de criar uma entidade pessoa onde apontamos os campos e os tipos dos campos, no ultimo uma outra entidade(usuario) montando o relacionamento ManyToOne.

Bem eu precisei dar essa parte básica do Doctrine para finalmente montarmos uma relação das annotations então, chega de enrolar.

Annotations Doctrine

@Column (O mais utilizado, e o mais básico)
Esse é o carinha que define a maioria das colunas que criamos dentro de nossas entidades, o proprio nome diz, é ele que marca um atributo como uma coluna válida no banco. Qualquer espera de valor dentro desta variável será salvo e carregado a partir do banco de dados como parte do ciclo de vida das variáveis de instância da entidade de classe.

Atributos requeridos:

type: Tipo do atributo para que seja criado a coluna no banco baseado nesse tipo como por exemplo char, int etc...

Atributos opcionais:

name: Por padrão o nome do atributo é o nome da coluna no banco(sem o $ é claro), mas pe possível determinar um outro nome para a coluna utilizando o name.
length: Usado para tipo "string" serve para determinar o limite máximo de caracteres dessa coluna. O Doctrine não valida o tamanho da string no funcionamento do sistema, oque aconteceria era um funcionamento comum onde apenas o limite liberado é que seria gravado no banco de dados.
precision: Marca a precisão de números decimais(número exato) da coluna (Aplicado apenas para colunas decimais)
scale: The scale for a decimal (exact numeric) column (Applies only for decimal column)
unique: Valor booleano que determina se o valo é unico.
nullable: Determina se coluna pode ser NULL.
columnDefinition: DDL SQL trecho que se inicia após o nome da coluna e especifica a definição de coluna completa (non-portable!). Este atributo permite fazer uso de recursos avançados RMDBS. No entanto, você deve fazer uso cuidadoso deste recurso tomando cuidado com as conseqüências. SchemaTool não irá detectar alterações na coluna mais correctamente se você usar "ColumnDefinition".

Além disso, você deve se lembrar que o "type" ainda lida com a conversão entre PHP e os valores do banco de dados. Se você usar esse atributo em uma coluna que é usada para junções entre tabelas você também deve dar uma olhada em @ JoinColumn.

Exemplos simples:

<?php
namespace GuestBook\Model\Doctrine\Entity;
/**
*
* @Table(name="guestbook")
* @Entity
*/
class GuestBookDoctrine{
/**
* @var integer $id
* @Column(type="integer")
* @Id
* @GeneratedValue(strategy="IDENTITY")
*/
private $id;
public function setId($id){$this->id = $id;}
public function getId(){return $this->id;}
/**
* @Column(type="string", length="100")
*/
private $title;
public function setTitle($title){$this->title=$title;}
public function getTitle(){return $this->title;}
}

Exemplo da documentação do doctrine:

<?php
/**
 * @Column(type="string", length=32, unique=true, nullable=false)
 */
protected $username;

/**
 * @Column(type="string", columnDefinition="CHAR(2) NOT NULL")
 */
protected $country;

/**
 * @Column(type="decimal", precision=2, scale=1)
 */
protected $height;

Bem acho que por hoje é só, até o próximo artigo sobre mais annotations do doctrine.

utilizando o VIM

noreply@blogger.com (Anonymous) — Sun, 11 Nov 2012 08:03:00 -0200

Olá amigos, hoje vou iniciar uma sequencia legal sobre o editor de textos VIM.
O sistema Operacional GNU/LINUX possui um editor de texto chamado VIM, no qual pode ser utilizado em terminais para a edição de arquivos de texto.

O Vim além de ser um editor de texto comum este também possui recursos para ser utilizado como um editor de programação, como por exemplo a mudança de usuário de comum para administrador, retirar senhas de usúario por algum motivo, editar configurações de arquivo, etc

Instalação do editor de texto VIM:

sudo apt-get install vim -y

Utilizando o editor de texto VIM para abrir um arquivo:

Super Usuário (root)
# vim [arquivo]

Usuário comum
$ vim [arquivo]

O editor de texto vim pode ser utilizado em dois modos diferentes:

modo de inserção de texto
modo de inserção de comandos

### MODO DE INSERÇÃO ###

Para entrar no modo de inserção de texto utilize:

aperte a tecla “I” ou a tecla “INSERT”

Através deste modo poderemos inserir texto no arquivo.

Para entrar no modo de substituição de texto aperte:

aperte a tecla “INSERT” 2x

Através deste modo poderemos substituir o texto dentro do documento, também chamado de modo REPLACE.

### Modo de comandos: ###
Salvar o arquivo

Sair do arquivo

Salvar e sair do arquivo

:wq

OBS: Caso queira forçar a execução de algum comando utilize “!”
Exemplo:
:q! -> Forçar a execução de saída do arquivo.
:w! -> Forçar a execução de salvar o arquivo.
:wq! ou :x! -> Forçar em salvar e sair ao mesmo tempo do arquivo.

Numerar as linhas do arquivo
:set number

Retirar a numeração imposta através do comando anterior
:set nonumber

Colocar Texto colorido
:syntax on

Retirar Texto Colorido
:syntax off

Pular para uma determinada linha
:Numero_de_linha

Exemplo:
Pular para a linha 15
:15

Ir com o cursor até o final do arquivo
:$

Ir com o cursor até o final do arquivo
:0

Inserir o conteúdo de um arquivo de texto dentro do arquivo no qual estiver editando
:r arquivo.txt

Executar um comando do shell sem sair do arquivo
:!COMANDO

Exemplo:
:!cat /etc/passwd

Executar um comando do shell e jogar a saída (RESULTADO) do comando para dentro do arquivo de texto
:r!COMANDO

Exemplo:
:r!cat /etc/passwd

Procurar por palavras dentro do arquivo de texto
/PALAVRA

Exemplo:
/futebol

Irá procurar a palavra futebol dentro de todo o arquivo, aperte a tecla “N” para pular para cada palavra futebol dentro do arquivo.

OBS: Através deste comando irá procurar do INÍCIO PARA O FINAL.

Procurar por palavras dentro do arquivo de texto
?PALAVRA

Exemplo:
?futebol

Irá procurar a palavra futebol dentro de todo o arquivo, aperte a tecla “N” para pular para cada palavra futebol dentro do arquivo.

OBS: Através deste comando irá procurar do FINAL PARA O INÍCIO.

Abrir uma sessão do sheel dentro do editor de texto
:shell

Para voltar ao arquivo digite: exit

Alterar palavras na linha atual
:s/palavra_antiga/palavra_nova/g

Exemplo:
:s/casa/CASA/g

Irá todas as palavras casa(minúsculas) na linha atual pela palavra CASA(MAIÚSCULAS).

Para alterar todas as palavras em todo o arquivo:
:%s/palavra_antiga/palavra_nova/g

Para manipular mais de um arquivo de texto ao mesmo tempo
:split [ARQUIVO] ou :sp [ARQUIVO]

Para alternar entre os dois arquivos utilize as teclas:
Ctrl+W

Selecionar texto

Utilize a tecla “V” em modo de comando.

Copiar texto:

Utilize a tecla “Y” em modo de comando.

Colar Texto:

Utilize a tecla “p” em modo de comando.

Apagar toda uma linha:

Utilize a tecla “D” 2x em modo de comando.

Copiar toda uma linha:

Utilize a tecla “Y” 2x em modo de comando.

Instalando pacotes .tar.gz no ubuntu

noreply@blogger.com (Anonymous) — Sun, 21 Oct 2012 16:15:00 -0200

Muitos usuários recém chegados no mundo Linux deparam-se com esse problema ao desejarem instalar determinado software que não vem por padrão na distribuição usada e ao fazer o download do arquivo, encontram um .tar.gz.

Ao longo desse artigo iremos mostrar como não existe nada de complicado nessa tarefa.

* Pacotes do tipo .tar.gz ou .tar.bz2 contém os fontes do programa prontos para compilação (transformar os fontes em executáveis).
* Sua instalação não depende da distribuição usada.
* O .tar significa que dentro desse arquivo existem outros e sub-pastas e o .gz ou .bz2 é o tipo de compactação que foi usada na criação do pacote.

$ cd /home/usuário (entra no diretório onde está o pacote)
$ ls (só para você ver o pacote que você baixou)
$ tar -jxvf nome_do_pacote.tar.bz2

DICA: Digite as primeiras letras e tecle tab.

Explicação do último comando: para extrair os arquivos de um pacote .tar.bz2 usa-se o comando listado acima, caso fosse um .tar.gz o comando seria bastante semelhante:

$ tar -zxvf nome_do_pacote.tar.gz

Ou seja, muda apenas em uma letra de "j" para "z" ou vice-versa. Recomendo que você procure saber o que significa cada uma dessas letras, para isso use o comando:

$ man tar

Agora listando os arquivos...$ ls
Vc vai perceber que foi criado um novo diretorio com o nome do pacote ou então um arquivo .bin correto?

Se for um .bin então é bem rápido, basta fazer:
$ chmod a+x nome_arquivo.bin
$ sudo ./nome_arquivo.bin

Caso seja um diretorio...

$ cd nome_do_diretório_criado
$ ls

Está vendo um arquivo chamado "configure"? Segue explicação abaixo.

Como o nome já sugere, esse arquivo 'prepara' o Linux para instalar o programa, checando dependências, entre outras coisas. Se encontrar problemas na etapa seguinte, leia o INSTALL ou o README, eles informam tudo que você precisa ter e/ou fazer para ter o programa funcionando perfeitamente.

$ ./configure

(o ./ significa que queremos executar esse arquivo)

OBS: Agora serão verificadas variáveis de ambiente e dependências de bibliotecas. Essa etapa demora um pouco, caso o configure encontre algum erro, anote-o, vá no install e veja se fala algo sobre.

$ make
$ make install (instala o programa no Linux)

Lista rápida de comandos:

* tar -zxvf nome-do-arquivo.tar.gz - desempacota o arquivo de extensão .tar.gz;
* tar -jxvf nome-do-arquivo.tar.bz2 - desempacota o arquivo de extensão .tar.bz2.

http://easy-ubuntu.blogspot.com/

Utilizando o LIKE no Doctrine

noreply@blogger.com (Anonymous) — Sun, 21 Oct 2012 09:23:00 -0200

Quer utilizar o LIKE com Doctrine? Essa é simples!

SIMMMMMMMMMMMMMMMMMM

Esse não é nem um artigo mas sim uma dica/lembrança para consulta rápida...

Utilizando QueryBuilder

<?php
// $qb instancia de QueryBuilder

$qb->select(array('u')) // string 'u' is converted to array internally
   ->from('User', 'u')
   ->where($qb->expr()->orX(
       $qb->expr()->eq('u.id', '?1'),
       $qb->expr()->like('u.nickname', '?2')
   ))
   ->orderBy('u.surname', 'ASC'));

E Utilizando DQL

<?php
$query = $em->createQuery("SELECT u FROM CmsUser u LEFT JOIN u.articles a WITH a.topic LIKE :foo");
$query->setParameter('foo', '%foo%');
$users = $query->getResult();

Bem, é isso rsrs...

Design Pattern Builder no PHP

noreply@blogger.com (Anonymous) — Tue, 2 Oct 2012 08:01:00 -0300

Olá amigos tudo bem? Vamos "filosofar" um pouco? Vamos falar sobre o Builder um design pattern que "deriva" do Factory mas tem suas particularidades.

ANNTISiSS DE INICIAR O ARTIGO VOU DAR UM AVISO AOS NAVEGANTES:
Não use um design pattern pq simplesmente ele é "elegante" ou então pq vc quer aprender e para isso vai jogar em código de produção para testar.
Use os patterns quando vc REALMENTE PRECISAR, vou repetir... REALMENTE PRECISAR! Muitas vezes as pessoas tornam algo simples em algo absurdamente complexo por não saber usar ou usar os os patterns em hora errada, se vc tem dúvidas se usa ou não o pattern procure entender melhor o problema e a solução que ele propõe antes de fazer uma tremenda de uma porcaria no código. Ok? :)

DESIGN PATTERN BUILDER

Como o próprio nome já diz ele é um pattern construtor(builder), otimo para quando vc precisa criar objetos completos que atendam uma certa complexidade. No Pattern Builder um temos um diretor e um construtor trabalhando juntos para construir um objeto. O diretor controla a construção e especifica quais partes e variações entram em um objeto. O construtor sabe como montar a especificação do determinado objeto. Em resumo a intenção do padrão Construtor(Builder), é separar a construção de um objeto complexo, de modo que o mesmo processo de construção possa criar várias representações diferentes.

Veja um exemplo claro de diagrama mostrando a implementação:

O diagrama é a mesma coisa que dizer que:
A classe Builder especifica uma interface abstrata para a criação de partes de um objeto Product.
O ConcreteBuilder constrói e reúne peças do produto pela implementação da interface Builder. Ele define e mantém o controle da representação que cria e fornece uma interface para guardar o produto
A classe Director constrói o objeto complexo usando a interface do Construtor

A Product representa o objeto complexo que está sendo construído.

Veja um exemplo classico de implementação:

BUILDER

<?php
class Fabrica {
public function Construir($oVeiculo) {
$oVeiculo->Iniciar();
$oVeiculo->construirPortas();
$oVeiculo->construirMotor();
$oVeiculo->construirPneus();
}
}
abstract class ConstrutorVeiculo {
protected $Veiculo;
abstract public function Iniciar();
abstract public function construirMotor();
abstract public function construirPortas();
abstract public function construirPneus();
}
class Carro extends ConstrutorVeiculo {
public $Veiculo;
public function Iniciar() {
$this->Veiculo = new Veiculo('Carro');
}
public function construirPortas() {
$this->Veiculo->aPartes['Portas'] = 4;
}
public function construirMotor() {
$this->Veiculo->aPartes['Motor'] = 1;
}
public function construirPneus() {
$this->Veiculo->aPartes['Pneus'] = 4;
}
}
class Moto extends ConstrutorVeiculo {
public $Veiculo;
public function Iniciar() {
$this->Veiculo = new Veiculo('Moto');
}
public function construirPortas() {
$this->Veiculo->aPartes['Portas'] = 0;
}
public function construirMotor() {
$this->Veiculo->aPartes['Motor'] = 1;
}
public function construirPneus() {
$this->Veiculo->aPartes['Pneus'] = 2;
}
}
class Veiculo {
private $sTipo = NULL;
public $aPartes = array();
public function __construct($sTipo) {
$this->sTipo = $sTipo;
}
public function ObterInformacoes() {
printf("--------------------------\n");
printf("Veículo: %s \n", $this->sTipo);
printf("Motor: %s \n", $this->aPartes['Motor']);
printf("Portas: %s \n", $this->aPartes['Portas']);
printf("Pneus: %s \n", $this->aPartes['Pneus']);
}
}
$Fabrica = new Fabrica;
$Carro = new Carro;
$Moto = new Moto;
$Fabrica->Construir($Carro);
$Carro->Veiculo->ObterInformacoes();
$Fabrica->Construir($Moto);
$Moto->Veiculo->ObterInformacoes();
?>

A explicação acima fala por si só não é? Mesmo assim qualquer dúvida... Fui

Paginação com Doctrine e Zend_Framework

noreply@blogger.com (Anonymous) — Mon, 17 Sep 2012 10:00:00 -0300

Olá amigos, hoje vou mostra basicamente como paginar dados usando o Zend Framework e o Doctrine, inicialmente parece algo complexo, mas vcs vão perceber que é simples.

Se vc ainda não fez uma paginação com o zend framework leia esse meu artigo sobre paginação com o ZF Paginando com Zend Framework e depois corra aqui, ou se preferir fique por aqui mesmo.

Vamos lá, vou mostrar a paginação de forma bem simples pois o grande problema de fazer um artigo sobre paginação do Zend Framework com Doctrine é que isso varia muito a arquitetura que cada um esta usando, mas nesse caso isso não vai atrapalhar pois vc vai adaptar de acordo com a sua arquitetura.

Mãos a obra

No controller....

  exemplo de consulta

 public function exemploAction() {

        $request = $this->getRequest();

        if ($request->getPost()) {

            $params = $request->getPost();

            $pagina = (int) $params['pag'];

            $front = \Zend_Controller_Front::getInstance();

            $em = $front->getParam('bootstrap')->getResource('entityManager');

            $dql = $em->createQuery("select a from Entidade_Pessoa a");

            $dados = new \DoctrineExtensions\Paginate\PaginationAdapter($dql);

            $paginator = new Zend_Paginator($dados);

            // Seta a quantidade de registros por página

            $paginator->setItemCountPerPage(4);

            // numero de paginas que serão exibidas

            $paginator->setPageRange(15);

            // Seta a página atual

            $paginator->setCurrentPageNumber($pagina);

        }

        $this->view->paginator = $paginator;

 }

Veja que simples, usamos uma paginação aparentemente comum do ZF não é? mas passamos para o zend_paginador a variavel $dados que contem a instância da PaginationAdapter que recebe a consulta dql e faz toda a brincadeira... esse cara esta aqui abaixo é uma classe que implementa a \Zend_Paginator_Adapter_Interface e por isso o Zend_Paginator sabe trabalhar com o objeto pois os métodos que ele usa são do nome da interface.
Lindo não é?

Veja a classe:

  ADAPTER DO DOCTRINE

/**

 * DoctrineExtensions Paginate

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE. This license can also be viewed

 * at http://hobodave.com/license.txt

 *

 * @category    DoctrineExtensions

 * @package     DoctrineExtensions\Paginate

 * @author      David Abdemoulaie <dave@hobodave.com>

 * @copyright   Copyright (c) 2010 David Abdemoulaie (http://hobodave.com/)

 * @license     http://hobodave.com/license.txt New BSD License

 */

namespace DoctrineExtensions\Paginate;

use Doctrine\ORM\Query;

/**

 * Implements the Zend_Paginator_Adapter_Interface for use with Zend_Paginator

 *

 * Allows pagination of Doctrine\ORM\Query objects and DQL strings

 *

 * @category    DoctrineExtensions

 * @package     DoctrineExtensions\Paginate

 * @author      David Abdemoulaie <dave@hobodave.com>

 * @copyright   Copyright (c) 2010 David Abdemoulaie (http://hobodave.com/)

 * @license     http://hobodave.com/license.txt New BSD License

 */

class PaginationAdapter implements \Zend_Paginator_Adapter_Interface {

    /**

     * The SELECT query to paginate

     *

     * @var Query

     */

    protected $query = null;

    /**

     * Total item count

     *

     * @var integer

     */

    protected $rowCount = null;

    /**

     * Use Array Result

     *

     * @var boolean

     */

    protected $arrayResult = false;

    /**

     * Constructor

     *

     * @param Query $query

     * @param string $ns Namespace to prevent named parameter conflicts

     */

    public function __construct(Query $query) {

        $this->query = $query;

    }

    /**

     * Set use array result flag

     *

     * @param boolean $flag True to use array result

     */

    public function useArrayResult($flag = true) {

        $this->arrayResult = $flag;

    }

    /**

     * Sets the total row count for this paginator

     *

     * Can be either an integer, or a Doctrine\ORM\Query object

     * which returns the count

     *

     * @param Query|integer $rowCount

     * @return void

     */

    public function setRowCount($rowCount) {

        if ($rowCount instanceof Query) {

            $this->rowCount = $rowCount->getSingleScalarResult();

        } else if (is_integer($rowCount)) {

            $this->rowCount = $rowCount;

        } else {

            throw new \InvalidArgumentException("Invalid row count");

        }

    }

    /**

     * Sets the namespace to be used for named parameters

     *

     * Parameters will be in the format 'namespace_1' ... 'namespace_N'

     *

     * @param string $ns

     * @return void

     * @author David Abdemoulaie

     */

    public function setNamespace($ns) {

        $this->namespace = $ns;

    }

    /**

     * Gets the current page of items

     *

     * @param string $offset

     * @param string $itemCountPerPage

     * @return void

     * @author David Abdemoulaie

     */

    public function getItems($offset, $itemCountPerPage) {

        $this->query->setFirstResult($offset);

        $this->query->setMaxResults($itemCountPerPage);

        $entities = $this->query->getResult();

        return $entities;

    }

    /**

     * @param Query $query

     * @return int

     */

    public function count() {

        if (is_null($this->rowCount)) {

            $this->setRowCount(

                    $this->createCountQuery()

            );

        }

        return $this->rowCount;

    }

    /**

     * @return Query

     */

    protected function createCountQuery() {

        return Paginate::createCountQuery($this->query);

    }

    /**

     * @return Query

     */

    protected function createLimitSubquery($offset, $itemCountPerPage) {

        return Paginate::createLimitSubQuery($this->query, $offset, $itemCountPerPage);

    }

    /**

     * @return Query

     */

    protected function createWhereInQuery($ids) {

        return Paginate::createWhereInQuery($this->query, $ids, $this->namespace);

    }

}

Veja que nós implementamos os métodos da interface e montamos o resultado então na view é só pegar como de costume o "$this->paginator" iterar ele e mandar bala!

Dúvidas? Me avisem pois fiz esse post meio correndo... rsrs

Contando objeto no PHP

noreply@blogger.com (Anonymous) — Tue, 11 Sep 2012 07:23:00 -0300

... Eis que surge a dúvida, como eu conto os atributos de um objeto? Será que count/sizeof funciona? Vamos testar?

Criando uma classe pessoa com os atributos nome, sexo e idade:

 CLASSE PESSOA

class Pessoa{

    private $nome;

    private $sexo;

    private $idade;

    public function getNome() {

        return $this->nome;

    }

    public function setNome($nome) {

        $this->nome = $nome;

    }

    public function getSexo() {

        return $this->sexo;

    }

    public function setSexo($sexo) {

        $this->sexo = $sexo;

    }

    public function getIdade() {

        return $this->idade;

    }

    public function setIdade($idade) {

        $this->idade = $idade;

    }

}

Vamos criar uma instância dessa classe e popular ela, depois utilizamos o count na busca de um resultado mágico ok?

tentando contar atributos de um objeto

$pv = new Pessoa();

$pv->setNome("Paulo Victor");

$pv->setSexo("M");

$pv->setIdade("23");

echo sizeof($pv);

E ai o que ele vai retornar? Nesse caso retorna 1 pois o objeto é válido e ponto. (If you try to do a sizeof or count with an object, it will always return 1 if the object is not null)

OBS: sizeof é um atalho para a função count

I ai ferro, será que tem algo específico para contar um objeto?

..... Pesquisando e pesquisando descobrimos que a melhor solução nesse caso é fazer um cast do objeto para array, juro, dentro do count isso é lindo, assim como diz na documentação do php veja:
You need to type cast the object as an array for it to count correctly. (fonte: http://www.php.net/manual/en/function.count.php)

Então ficaria assim:

 contaNDO atributos de um objeto

$pv = new Pessoa();

$pv->setNome("Paulo Victor");

$pv->setSexo("M");

$pv->setIdade("23");

echo sizeof((array) $pv); // 3

Pronto, a saída disso será 3, o número de atributos.

Que simples não é? Igual a epoca em que jogavamos Alex kidd(foto, graaande alex kidd)

Pois bem, ai talvez vc me faça uma pergunta(diga-se de passagem, muito inconveniente kkkk) se não existem forma de tornar a contagem mais lógica de objetos, e ai amiguinho eu te dou uma resposta de alto nível que é; O PHP se preparou para tudo(quase tudo) e para esses casos existe a interface ArrayAccess que permite vc manipular objetos como array e array o PHP já tem 321402342034923049203492304 funções.
Mas, esse é um assunto para o próximo artigo(que eu juro q vou falar sobre).

Agora se vc quer contar exatamente um atributo e não quer ter muito trabalho eu idico dar uma lida na interface Countable da SPL(uma biblioteca com diversas classe e interfaces para PHP, que vão desde estruturas de dados, implementações de Design patterns, Iterators, Exceptions e funções diversas) aqui no blog do Thiago Rigo tem uma boa explicação sobre ela http://thiagorigo.com/blog/2010/07/spl-countable/

Então é isso. Valeu!