Elf Blog

Este post irá descrever de forma mais completa o que a gem gploy faz, acredito que não será um post grande pois a gem não faz tanta coisa assim. Gploy é uma RubyGem que pode ser usada para configurar seu projeto Ruby on Rails e seu servidor para realizar deploy usando git. De forma alguma quero tentar substituir ou algo assim gems muito melhores e eficientes como o Imploy ou o locarails, até mesmo pois essas fazem o trabalho de outra forma.

Resumo

Gploy é uma Gem Ruby simples para configurar e fazer deploy de apps Rails, essa gem foi escrita por min(Edipo), o codigo não esta elegente como deveria, mas estou trabalhando nisso .

O que preciso ter.

Se faz necessário o uso de git para controle de versão de seu projeto Rails, o que acredito que seja praticamente impossível alguem do Rails não esta usando git para versionamento, você também precisa um servidor web(sério?) que rode Ruby on Rails, até agora somente testei na locaweb, pois essa gem faz o uso de uma estrutura de pasta em particular que é encontrada nos servidores da locaweb(mas imagino que outros servidores não são diferentes disso), outra coisa muito importante é que, novamente, até o momento, essa gem faz o uso de um repositório git no mesmo servidor que irá esta hospedada a aplicação, então seu servidor também precisa ter suporte a git. Dito isso, a estrutura de pasta que o gploy usa é a seguinte:

~/repos -> Repositorio git
~/rails_app -> Onde fica seu projeto de produção
~/public_html -> Aqui irá ser criado um link simbólico com a aplicação.

Logo a pasta repos poderá ser substituída por qualquer uma de sua preferencia atras de uma configuração adicional.

Que arquivos são usados

Os comandos gploy -c e gploy -pr geram dois arquivos, config/config.yaml e config/post-receive respectivamente. O primeiro é um arquivo yaml que guarda as informação do seu servidor, nome da app e origin(git).

Acho que não tem muito o que falar sobre esse arquivo ele é auto-explicativo, apenas tome cuidado com a ultima linha(origin) caso você já tenha no seu git um origin configurado use outro nome. Caso você tenha um key ssh configurada para seu servidor na sua maquina e não necessite senha simplesmente deixa essa opção em branco.

O segundo arquivo é o post-receive que é um hook do git, basicamente falando é um arquivo que é executado sempre que o repositório em questão sofre algum tipo de ação, no nosso caso é quando ele recebe um push, esse arquivo se parece com isso:

Esse conteúdo é o que é gerado pelo gploy, também acho que é auto-explicativo o que ele faz, caso você tenha mais tarefas para serem executadas quando você der um novo deploy simplesmente coloque ela nesse arquivo usando o env -i na frente como os demais.

Como a gem Trabalha.

A forma como a gem trabalha é bem simples, o que ela faz é usar um pouco do poder do git ao seu favor, basicamente é:

→ Se projeto não estiver versionado então inicio um repositório git localmente e faça o primeiro commit.
→ Adiciona a url remota configurada no config.yml ao git
→ Faz um git push
→ Faz um clone dentro do servidor da pasta repos para rails_app
→ Adiciona a url “remota” dentro do servidor
→ Cria o link simbólico entre public_html e rails_app
→ Cria diretório tmp na aplicação caso não existir
→ Faz upload do arquivo de hook configurado anteriormente
→ Roda Migrations e Restart Servidor

Isso é o que acontece quando você executa gploy -s. Nesse momento seu projeto esta no ar, se tudo aconteceu como o esperado.

Novos Deploys.

Toda vez que você quiser atualizar seu projeto em produção simplesmente faça gpoy -d, ele irá ir até a branch master e fazer um simples push.

Quando usar essa gem?

Eu não recomendaria usar ela para algum projeto real no qual você possa perder dinheiro se o mesmo não estiver ok no ar. Mas acredito que se você esta desenvolvendo algo mais simples e quiser simplesmente colocar em produção para testes externos, ou até mesmo para colocar em produção sistemas ou Web Sites mais simples e que não precisem ficar 24/7 online acredito que possa vir a ser útil, eu até mesmo uso em algumas coisas que estão online.

Logs

O gploy mantem arquivo de log bem simples, ele simplesmente informa qual comando foi executado e se o mesmo foi feito localmente ou remotamente, você pode encontrar esse arquivo dentro da pasta logs do seu projeto Rails.

Testes

Essa gem não tem cobertura 100% de testes unitários, basicamente o que mantenho até o momento são 22 testes usando Rspec. Obviamente não esta tudo testado com esse numero, mas por hora já me ajuda a não ter muita dor de cabeça na hora de mexer no código do projeto. Abaixo o resultado gerado pelo Rcov para a cobertura de testes dessa gem.

Funcionalidades Futuras.

Ainda não tenho nada certo para novas funcionalidades do gploy, o que pretendo implementar é um forma de poder deixar para o usuário escolher qual pasta quer usar para repositório(ou seja, se quiser mudar o nome de repos para qualquer outro), também uma forma simples de usar seu repositório do github, já que o mesmo suporta hooks.

Conclusão

Esta é uma RubyGem simples mas que pode ser útil em certas situações, caso você tenha gostado, faça um fork do projeto no github e sugira modificações e correções de bugs. E quem tiver acesso a outros servidores que não sejam da locaweb por favor entre em contato para que possamos realizar alguns testes, mas penso que a estrutura seja a mesma praticamente.

Links:
Source Code: http://github.com/edipofederle/gploy/
RubyGems: http://rubygems.org/gems/gploy

Git Documentation: http://git-scm.com/documentation

Hoje estava configurando o Rcov para o gploy, e na hora de gerar as estatisticas de cobertura de testes para o projeto alguns erros aconteciam, basicamente algo como a imagem abaixo:

Após um pouco de investigação o que acontece(eu acho) é que como estou fazendo o uso do FakeFs em meus testes e como o rcov precisa rodar os testes(obviamente) ele da erro ao tentar copiar os arquivos necessarios de template do rcov(reparem o comando cp ali), e como isso é manipulação de arquivos ele falha, ao tentar usar o FakeFs para fazer tal operação, já que o mesmo esta ativo em nossos casos de testes.
Solução

Em seu arquivo de teste onde é feito o uso deo FakeFs provalmente você tenha algo assim.

O que fiz foi usar o before e after para ativar e desativar o fakefs.(agora me veio uma solução mais simples, active no inicio e de deactivate no final do teste, mas não tenho como testar isso agora ).

Abaixo segue a tarefa rake para rodar o rcov, caso esteja usando testunit ao invés de rspec mude o local de arquivos de testes de spec para test.

Bom é isso pessoal, espero que ajude alguem.

Até Mais.

Olá pessoas, finlamente estamos devolta para falar novamente de Ruby, dessa vez iremos dar uma olhada básica na criação de classes em Ruby.

Iremos fazer nossos exemplo em cima de uam classe chamada Matemática.

Definição de uma Classe

Simples como só o Ruby poderia ser , usamos a palavra chave do Ruby class para criar uma nova constante para fazer referência a nossa classe, nome de classe e constante ambas são as mesma, é por isso que devemos declarar classes com letra Maiúscula.

A palavra chave self

Podemos usar a palavra self para nos referir a própria classe, essa palavra vem dentro da definição da classe, por exemplo.

Criando uma Instância de Matematica

Até o momento ainda não colocamos nada de atributos ou métodos em nossa classe, mas isso não impede que agente crie uma instância dessa classe, para isso usamos a palavra-chave new.

Todo e qualquer objeto de classe tem um método new.

O que temos de importante para fazer com um objeto que não tem nenhum método ? Bem podemos pedir para ele qual é seu tipo, para tal operação:

Inicializar a Nossa Classe

Construtores é a palavra se você vem ou é do mundo Java, queremos inicializar nossa classe com dois argumentos x e y. Mas como você não está no Java aqui isso se chama initialize.

Simples heim, mas o que aconteceu nessas três novas linhas? Primeiramente usamos a palavra-chave def para definir nossa método initialize, vale dizer aqui que esse def define um método de instância da classe, quando vamos chamar um método de instância da classe o valor de self é uma instância da classe na qual o método foi declarado.

Bom, quando definimos uma initialize para uma classe, temos que saber que quando usamos o método new para criar um nova instância da nossa classe, ele chama automaticamente o método initialize para aquela instância, então todo e qualquer argumento que você passar para new irão ser passados para o initialize, então como nosso initialize está esperando dois argumentos devemos agora passar esses argumentos no momento em que criamos nosso objeto Matematica.

Pronto agora sim. Algo bacana que acontece internamente no Ruby é que o método intialize é PRIVATIZADO automaticamente. Ou seja um objeto por ele mesmo pode chamar esse método para fazer a inicialização de seus argumentos, mas você não pode fazer uma chamada explicita para por exemplo mudar os valores de inicialização.

O que temos dentro do método initialize é dois valores que passamos nas variáveis @x, e @y, em Ruby o que começar com @ é uma variável de instância, então podemos ter n instância de Matematica que cada um delas terá seus próprios valores para x e y.

Uma consideração sobre variáveis de instância é que elas somente podem ser acessadas pelos métodos de instância do Objeto. Ou seja se houver algum código que não esteja dentro de um método de instância não poderá ler ou modificar seu valor. Na verdade existe uma maneira de fazer isso usando algumas técnicas de reflexão(reflections)

Certamente se você esta pensando em Java ou outras linguagens estáticas ficou pensando em fazer a declaração das variáveis, se você fizesse isso podia até pensar estar fazendo a coisa certa mas não está, no Ruby as variáveis de instância são resolvidas todas em contexto self, no momento em que é invocado o método initialize o self mentém uma instânia de nossa classe(Matematica), ou seja, o código fora do initialize faz referência à definição da classe e não a INSTÂNCIA da classe, então quando a leitura das variáveis que você declara fora(como no Java, por exemplo) são totalmente diferentes daquelas dentro do initialize.

O quase sempre presente método to_s.

Isso é praticamente default em todas as classes que você fizer, isso para poder retornar uma representação da sequência do objeto.

Bem melhor que antes não:

Saídas

com to_s: (3,4)

sem to_s: #

Bom essa foi a primeira parte, logo logo eu posto mais, obrigado por ler

Olá pessoas, ja fazia um tempão que não postava nada aqui, mas a coisa anda corrida por esses lados, mas vamos ao post.

Recetemente lancei para o público a primeira gem que me arrisquei a fazer, essa gem está longe de ser perfeita e também esta bem longe de ter um bom código, mas como é a primeira me perdoem .

O que essa gem faz é simplesmente configurar seu projeto rails para usar o git para automatizar seu deploys, essa gem usas as configurações citadas pelo Fábio Akita neste post, ou seja configura seu projeto localmente e o seu servidor para isso. Como sstou com um pouco de preguiça irei colocar aqui somente por enquanto o link para o github e la tem a documentação(em inglês) de como usar(é fácil).

Github Projet Page

RubyGem Page

Valeu pessoas e comentem.

Warning: Missing argument 1 for GeSHi::GeSHi(), called in /home/storage/f/73/ab/bitside1/public_html/edipo_blog/blog/wp-content/plugins/codecolorer/codecolorer-core.php on line 137 and defined in /home/storage/f/73/ab/bitside1/public_html/edipo_blog/blog/wp-content/plugins/deans_code_highlighter/geshi.php on line 432

Warning: Missing argument 2 for GeSHi::GeSHi(), called in /home/storage/f/73/ab/bitside1/public_html/edipo_blog/blog/wp-content/plugins/codecolorer/codecolorer-core.php on line 137 and defined in /home/storage/f/73/ab/bitside1/public_html/edipo_blog/blog/wp-content/plugins/deans_code_highlighter/geshi.php on line 432

Em linhas gerais uma exceção é um objeto que indica um tipo de condição excepcional, ela indica que algo muito errado aconteceu, um clássico exemplo de exceção é a divisão por zero, aposto que todos já passaram por algum caso de divisão por zero, chamar métodos que não existem, passar argumentos errados para métodos e assim por diante, esses exemplos citados são todos erros de programação, mas uma exceção não é somente levantada por conta disso, também podemos ter outros tipos de exceções como tentar fazer o uso da rede quando a mesama estiver off.

Não irei falar mais sobre o que são exceções mas recomendo fortemente a leitura na wikipedia sobre isso.

Quando algum erro acontece, por exemplo à passagem de um argumento inválido para um método qualquer dizemos que uma exceção é levantada, por padrão o Ruby finaliza o programa quando algo do tipo acontece, mas como iremos ver é possível fazer à declaração de manipuladores de exceções, isto é um bloco de código que é sempre executado se uma exceção acontecer na execução de um bloco de código, quando uma exceção é levantada o que acontece é a transferência do fluxo de controle para um código que irá tratar essa exceção. Possivelmente você pode tentar fazer uma comparação com a delaração break para sair de um laço por exemplo, mas como iremos ver mais adiante as exceções são bem diferentes, poderosas e flexíveis ao ponto de nos premitir transmitir o fluxo para n blocos.

No Ruby podemos fazer o uso do método raise para levantar exceções e fazer o uso da cláusula rescue para tratar as exceções.
Todas exceções que são levantadas por raise são uma instância de classe Exception ou de alguma de suas subclasses.

Segue abaixo a hierarquia da classe Exception:

Logicamente voçê não tem que saber cada uma delas(seus nomes não bem óbvios) o que você deve ter em mente é que algumas dessas classes extendem uma classe conhecida como StandardError, ou seja, exceções, digamos assim que acontecem com mais frequência, algumas outra expressões representam níveis bem mais baixos, coisas que com menos possibilidade de recuperação logo os programas Ruby(normalmente) não tentam fazer a sua manipulação.

Objetos dos métodos de excecção.

Temos dois métodos que podem retornar alguns detalhes sobre uma dada exeção, esses métos são da classe Exception, message irá retornar uma sequência que permite obter alguns detalhes que podem ser entendidos por seres humanos, facilitando o entendimento de erros.
Também temos outro método bastante importante que é o backtrace, backtrace irá retornar um array de sequências representando uma pilha no ponto em que a exceção foi levantada.

A[0] = posição no qual a exceção foi levantada.
A[1] = posição no qual o método que levantou a exceção foi chamado.
A[2] = posição no qual esse método foi chmado.

E por ai vai, para poder ver um rastreamento da pilha o Ruby fornece um Método Kernel caller.

Objetos de Exceção.

Objetos de exceção são criados pelo método raise, também temos a opção de fazer a criação de nossos próprios objetos, normalmente usando o new ou com outra classe de métodos exception.

Lançando Exceções com Raise.

Quando um método do Kernel é sobreescreito uma exceção é levantada, fail é usado certas vezes quando há certa expectativa que seu programa deva ser finalizado pela exceção.
Existem n formas de se invocar o método raise, veremos abaixo algumas dessas formas:

Raise sem Argumentos

Se o método raise for chamado sem nenhum argumento, o mesmo irá criar um objeto do tipo RunTimeError que não irá ter nenhuma mensagem e então o levanta, por hora se raise for usado também sem argumento mas dentro de um rescue(iremos ver logo ele) o que irá acontencer é que a exceção(que estava sem manipulada) irá ser re-levantada.

Raise com um único argumento

Caso o raise for chamdo com um único argumento (objeto exception) ele irá levantar essa exceção.( Não é um forma muito comun se fazer o uso do raise)

Raise com uma sequencia de argumentos.

Neste caso será criado um objeto novo de exceção( RunTimeError), é uma forma comun de fazer o uso do raise.

Raise com objeto que possua uma exceção

Neste caso raise invoca tal método e levanta o objeto Exception que o mesmo retona.
OBS: A classe Exception possue um método exception, isso quer dizer que você pode especificar a classe do objeto para qualquer tipo de exceçao para ser o primeiro argumento do raise.

Raise com sequencia no terceiro argumento

Neste caso um array de sequências é especificado e então serão usados como o backtrace do objeto(exceção).
OBS: Caso este terceiro argumentos não esteja especificado raise ira usar Kernel caller no backtrace.

Exemplo 1:

Até agora falamos muito, mas não colocamos nada em código ainda, vamos fazer um exemplo bem simples para começar, meio batido mas vou usar o exemplo fatorial novamente.

ruby ex.rb
120
24
3628800
ex.rb:2:in `fatorial’: Argumento invalido (RuntimeError)
from ex.rb:10

Este caso se encaixa no tipo de uso do raise um um único argumento, como dito antes temos outras formas de fazer a mesma coisa, por exemplo:

raise “Argumento invalido” if n < 1
pode ser perfeitamente substituido por:
raise RuntimeError "Argumento invalido" if n < 1
raise RuntimeError.new "Argumento invalido" if n < 1 ou
raise RuntimeError.exception "Argumento invalido" if n < 1

Claramente uma exceção RuntimeError não parece o mais apropriada para o caso do fatorial acima seria mais adequado usar um ArgumentError, ficando assim:

ruby ex.rb
120
24
3628800
ex.rb:2:in `fatorial’: ArgumentError (ArgumentError)
from ex.rb:10

ou até mesmo você pode personalizar um pouco essa mensagem, por exemplo fazendo o seguinte:

ruby ex.rb
ex.rb:7: Esperava um argumento >= 1. Mas retornou -4 (ArgumentError)

Bom, bem melhor a mensagem assim ? O exemplo do fatorial é um código simples, você não irá querer escrever testes unitários para ele(devia), pois podemos pensar facilmente nos casos em que ele irá falhar, se o código fose algo mais complexo e com n casos seria muito útil termos testes para eles, mas será que esse código de fatorial está ok ? claramente vemos que ele simplesmente checa se o número é positivo, mas não chega o tipo, isso pode ser facilmente resolvido adicionando um outro raise, assim:

E por curiosidade aqui vai um simples teste unitário para o código acima:

Uma coisa que deve ser entendida aqui, é que muitas vezes exceçõe irão acontecer mesmo sem agente levanta-lás, ou seja, exceções no próprio código Ruby, então uma lição importante é saber manipula-lás mesmo sem agente nunca lenvantar sequer uma delas.

O manipulador de Execções rescue

O rescue é um declaração que deve ser usada em conjunto com a declaração begin, begin é um delimitador de bloco de código dentro das exceções sendo manipuladas(Vimos um pouco disso no post anterior), a declaração begin parece bom isso:

OBS: o Exception => e é opcional, mas logo vermos que ele é útil.e

Dando um nome para um Objeto de Exceção

Podemos usar váriaveis para atribui-las um objeto de exceção(Exception), por exemplo:

=>ArgumentError: Argumento Invalido

Agora temos um váriavel global que faz referência ao objecto de exceção ( Exception ), essa váriavel é a $!, temos outras n variáveis globais, outra interessante é a $@ que retorna o local do último erro.

Uma coisa a ser notada aqui é que a váriavel e ficará disponível após o rescue ser finalizado, veja esse exemplo:

Exceções por Tipo

As execções mostras acima com o uso do rescue trata exceções StandardError, ou suas subclasses, outras exceções que não tiverem dentro dessa hierarquia sera ignorado, então como podem tratar qualquer tipo de exceções ? Simples, faça o seguinte:

Resuce Exception

Agora você deve saber que para manipular um ArgumentError e atribuir isso para e, é simples:

Rescue ArgumentError => ex

E para definir mais que um tipo? Simples, simplesmente separe por virgula(,) elas.
Então vemos um exemplo de como tratar duas exceções, ArgumentError, e TypeError, mas queremos tratas ambas de forma diferentes.

Bom pessoal essa foi a primeira parte sobre como tratar exceções no Ruby, na segunda parte iremos ver sobre propagação de exceções, exceções que ocorrem dentro de exceções e outras coisas mais.

Espero que tenham gostado e comentem