Instalando pacotes .tar.gz no ubuntu

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

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

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

1. <?php
3. class Fabrica {
5.     public function Construir($oVeiculo) {
6.         $oVeiculo->Iniciar();
7.         $oVeiculo->construirPortas();
8.         $oVeiculo->construirMotor();
9.         $oVeiculo->construirPneus();
10.     }
12. }
14. abstract class ConstrutorVeiculo {
16.     protected $Veiculo;
18.     abstract public function Iniciar();
20.     abstract public function construirMotor();
22.     abstract public function construirPortas();
24.     abstract public function construirPneus();
25. }
27. class Carro extends ConstrutorVeiculo {
29.     public $Veiculo;
31.     public function Iniciar() {
32.         $this->Veiculo = new Veiculo('Carro');
33.     }
35.     public function construirPortas() {
36.         $this->Veiculo->aPartes['Portas'] = 4;
37.     }
39.     public function construirMotor() {
40.         $this->Veiculo->aPartes['Motor'] = 1;
41.     }
43.     public function construirPneus() {
44.         $this->Veiculo->aPartes['Pneus'] = 4;
45.     }
47. }
49. class Moto extends ConstrutorVeiculo {
51.     public $Veiculo;
53.     public function Iniciar() {
54.         $this->Veiculo = new Veiculo('Moto');
55.     }
57.     public function construirPortas() {
58.         $this->Veiculo->aPartes['Portas'] = 0;
59.     }
61.     public function construirMotor() {
62.         $this->Veiculo->aPartes['Motor'] = 1;
63.     }
65.     public function construirPneus() {
66.         $this->Veiculo->aPartes['Pneus'] = 2;
67.     }
69. }
71. class Veiculo {
73.     private $sTipo = NULL;
74.     public $aPartes = array();
76.     public function __construct($sTipo) {
77.         $this->sTipo = $sTipo;
78.     }
80.     public function ObterInformacoes() {
81.         printf("--------------------------\n");
82.         printf("Veículo: %s \n", $this->sTipo);
83.         printf("Motor:   %s \n", $this->aPartes['Motor']);
84.         printf("Portas:  %s \n", $this->aPartes['Portas']);
85.         printf("Pneus:   %s \n", $this->aPartes['Pneus']);
86.     }
88. }
90. $Fabrica = new Fabrica;
91. $Carro = new Carro;
92. $Moto = new Moto;
94. $Fabrica->Construir($Carro);
96. $Carro->Veiculo->ObterInformacoes();
98. $Fabrica->Construir($Moto);
100. $Moto->Veiculo->ObterInformacoes();
103. ?>

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