Nesses ultimo dias tinha criado uma classe para resolver as expressões na notação posfixa, segue o link do github:

http://github.com/edipofederle/PostfixEvaluation

Olá esse post irá ser um pouco diferente do que venho escrevendo por aqui, esse é um assunto assim digamos mais teórico(realmente a palavra não é essa), enfim, vou falar um pouco aqui sobre a notação Infixa e Posfixa, e também sobre o algoritmo para resolver uma conversão de infixa para posfixa.

Notação Infixa

Notaçao infixa é quando na expressão temos os operedatores binários colocados entre os operandos, ou seja o que estamos mais acostumados a fazer. Algo como:Sabemos que nessas expressões as vezes se faz necessário o uso de paranteses para nao ocorrer ambiguidade.(regras de prioridade). Por exemplo:NOTA #1: Estou considerando apenas oprações binárias.

Esse tipo de expressão torna o trabalho computacional muito mais complicado.

Notação Posfixa

Notação posfixa é aquela onde os operadores estão localizados após os operandos, dessa forma não se faz preciso parenteses. Por exemplo, a expressão acima ficaria assim:Simplificamos bem a expressão escrevendo ela de forma posfixa.

Convertendo Expressões de Infixa para Posfixa

Árvore de expressão Binária

Uma árvore de expressão binária nos mostra de forma clara a precedencias e a associetividade dos operadores em uma expressão, dada a expressão na notação infixa:temos a seguinte árvore de expressão:

Agora dada uma expressão na forma posfixa:temos a seguinte árvore de expressão:

Se avaliarmos essa expressão de forma “Postorder Traversal” iremos ter a expressão na forma posfixa.

Algoritmo

A conversão de infixa para Posfixa é feita usando uma técnica chamada operator precedence parsing, precisamos usar a estrutura de dados do tipo pilha(stack), o algoritmo funciona da seguinte forma.

Data um expressão infixa faça:

– Add um parenteses esquerdo ‘(‘ na pilha;
- Add um parenteses direito ‘)’ à expressão infixa;
- Enquanto a pilha não estiver vazia ler a expressão infixa da esquerda para a direita e então:
- se o caractere lido por um digito(ou variavel) -> então add na saida(posfixa);
- se o caractere lido por um parenteses esquerdo ‘(‘-> entao add na pilha;
- se o caractere for um operador entao faça:
- Enquanto operador no topo da pilha tiver precedencia igual ou maior que a do operador lido -> Remove operador do topo da pilha.
- add o caractere atual a pilha;
- se o caractere aqual for um parenteses direito ‘)’;
- enquanto não achar um parenteses esquerdo ‘(‘ no topo da pilha faça:
-> Remover operador do tipo da pilha e add a saida(posfixa)
-> remover e descartar o parenteses esquerdo ‘(‘;

Código Java

Baixo segue o link para o github onde esta a classe para em Java para conversão, vale lembrar que acabei por escrever esse post pois encontrei esse problema no site TDD Problems que por sinal recomendo a todos para práticar TDD e programação, tem problemas bem legais lá, desde coisas simples até complexas, entao de uma olhada no código que escrevi para esse problemas, não sei o quão bom esta, mas esta com todos testes de unidade passando , tentei deixar a classe bem limpa, clara e pequena, as funções estão pequenas, mas acho que não é o bastante ainda, podemos simplificar bem mais, alguns métodos estão um pouco feios também(necessita de mais refatoração certamente).

A classe é dividida nos seguintes métodos:

converterToPostFix(String infix)
removeFromStackUntilFindRightParenthesis(String postfix)
isADigit(String digit)
isOperator(String ch)
precedence(String top, String ex)

Acredito que os nomes estão bastante sugestivos quanto as suas responsabilidades.

Código Fonte: http://github.com/edipofederle/InfixToPostfixConverter

É isso pessoal, espero que tenha sido útil para alguem, e deixe-me saber de qualquer problema com esse código, podem criticar (mas fazm fork e arrumem a sujeira ).

Até Logo.

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

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.

Primeiros os Testes de Unidade.

Depois as duas classes.

É isso, espero sugestoes e muitas criticas para refatorar

Motivação

Bom, normalmente eu não escrevo posts no estilo que esse irá(está) ser escrito, minha motivação para escrever tal texto já vem se criando à um certo tempo, mas agora finalmente resolvi escrever mesmo que o que venho à apresentar seja totalmente bobagem para muitos, mas tenho certeza que será correto ou resoavelmente bom para muitos.

Grande parte da motivação para eu escrever esse texto vem de vários lugares, como por exemplo: universidade,…. bom basicamente a universidade encapsula todo o resto, o que inclue professores, alunos e outras n váriaveis. ( ou seriam constantes??)

Bom dito isso vamos começar.

Nota I

Quero deixar bem claro aqui que não sou um conhecedor profundo de NADA, muito menos dos tópicos desse posts. Tudo que for apresentando aqui se refere basiscamente ao que eu penso e idéias das quais simpatizo.

Entregue-me um diagrama e lhe entregarei um Software

A grande maioria das universidade(ou não) ensinam UML, não vamos entrar em questões se isso é bom ou ruim, o fato é que UML não é tudo, você não consegue fazer um software apenas com um(s) diagrama(s) UML, e certamente você não não irá fazer um software seguindo fielmente uma especificação de diagrama de classe por exemplo, é basicamente sobre isso que esse post irá tratar…..

Diagramas, Diagramas, Diagramas

Sejamos sincero com nos mesmo, somente UML não é suficiente, o que muitos pregam por ai parecendo xiitas é que a única coisa que você precisa para fazer um software é uma especificação vinda de algum analista de sistema ou sei la quem vestindo um terno.  Não estou falando aqui que a UML não é boa ou que não resolve alguns problemas, de forma alguma, acho a UML um ótima ferramenta para expor visualmente algumas idéias e fluxos mais complexos de um sistemas,  mas onde eu acredito que realmente reside o bom uso de UML é na comunicação, ou seja fazer realmente o que seja importante, não sair desenhando todas as classes do sistema e em cada classe todos atribuitos e métodos, isso é simplesmente perda de tempo, acredito que o bom uso da UML seja pra coisas realmente importante, algo como “para se ter uma ideia”. Você quer detalhamento? Qual melhor local para isso do que no código?, é nesse que você tem que ser detalhado, cuidadoso e muito especifico, pois é isso que irá fazer seu software funcionar ou não.

Agora vamos ser realistas, na grande parte das vezes os Softwares não passam de um monte de cadastros(CRUDs e mais CRUDs) e não me entra na cabeça fazer meia dúzia de diagramas para fazer especificações sobre como implementar um simples CRUD que em 90% dos casos não tem nada de especial e nem vou entrar no assunto de documentações de casos de uso, ah ia me esquecendo casos de uso de ….. CRUD.

Acredito que grande parte disso tudo venha do modelo de desenvolvimentos tradicional de software o cascata, onde existem níveis bem definidos e funções bem especificadas em cada nível, ou seja:

Finalizada um etapa podemos seguir para a próxima, basicamente aquela história, “toma aí o diagrama peão(programador) codifica essa especificação assim como um pedreiro segue uma planta de um engenheiro, no final você vai ter um software “. Usei a palavra peão para programador pois é assim que se parece, e é assim que muitos pensam. Essa abordagem me sugere dois principal resultados, um, o projeto de software é concluído fora do prazo, do orçamento e em grande parte das funcionalidades não batem com o que o cliente solicitou, o sistema vai para produção e a empresa fica eternamente pagando manutenções para que sejam corrigidos problemas que  deviam ter sido detectados na face de analise ainda( e que passaram despercebidos pelos testes), problemas esses muitas vezes de mal entendimento de requesitos do cliente; segunda, o software não é finalizado.

Então a UML não serve ?

Sou suspeito para falar isso, sou um fã de metodologias agéis, como eXtreme Programming por exemplo, eu realmente nunca ouvi falar de uma equipe XP usar diagramas de UML para nada, e segundo a literatura existente isso é pouco feito, segue um trecho do artigo “O Design Está Morto?” de Martin Fowler, que recomendo a todos ler.

“Há diversos pontos de incompatibilidade. É fato que XP possui muito pouca ênfase em diagramas. Embora a posição oficial é a de “usá-los quando eles forem úteis”, há uma mensagem implícita que diz que “verdadeiros adeptos de XP não fazem diagramas”. Esta conclusão é reforçada pelo fato de que pessoas como Kent não se sentem confortáveis com diagramas; na verdade eu nunca vi Kent voluntariamente desenhar um diagrama de software em uma notação determinada.”

E nem é pelo fato de não se usar de diagramas que não teremos um bom software, existe outras n técnicas para tal função que acredito ser muito mais interessante e mais proxima do cliente também, como os cartões CRC:

Acho isso muito elegante e eficiente, recomendo ler http://www.agilemodeling.com/artifacts/crcModel.htm que foi de onde tirei essas duas imagens acima.

Não estou falando aqui que deve-se substituir UML por cartões CRC, o que eu falo é que existe algumas situações onde cada um tem seu maior valor e praticidade, ou um junção de ambos como o Martin Fowler diz que usa, na realidade o que o que realmente importa é saber medir as coisas e saber usar a coisa mais adequada em cada situação e não tentar forçar o uso de uma única ferramenta para resolver todos os problemas e esperar grandes resultados.

O que realmente queria dizer nesse post todo é que muitas vezes principalmente em universidade e certos professores acabam achando que aquilo que é passado na aula é tudo o que se tem para resolver problemas, e só aquilo que deve ser usado e pronto, me de ótimos resultados com isso, quando as coisas são muito mais complicadas… ou posso simplesmente esta falando bobagem….. quem sabe.

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

Uma das coisas que eu sempre achei muito bacana no Rails é a parte do ActiveRecord,(active record pattern) uma característica que particularmente gosto é a criação automatica dos timestemp das tabelas no banco de dados, no Rails quando tempo um modelo(model) quase sempre temos um tabela relacionada a esse modelo no banco de dados, para título de curiosidade do pessoal do Java vou apresentar abaixo uma classe(model) que representa um produto.

OBS: essa linhda validates_presence_of: eu coloquei somente para não deixar a classe vazia, ela faz a validação do campo nome e descrição.

Simples não? Claro temos a migration para isso.

Ultimamente eu estou tendo um contado maior com Java e Hibernate, não vamos falar sobre Java vs Ruby aqui(ainda), então eu estava mapeando classes para o banco e me vi sem os timestamps, pensei, o hibernate é algo bacana provavelmente tenha algo parecido, uma olhada no google e na documentação e achei uma forma bem bacana e de certa forma elegante(não quanto o Ruby, xiita ) de se fazer tal funcionalidade.

Abaixo apresento uma classe Java Product que faz o uso do timestamp através de anotações do Hibernate.

Bom um tanto elegante também, mas … bom, tirei os gets e sets para deixar mais pequena, com essas anotações(@prePersist, @PreUpdate) iremos ter esses campos no banco igualmente temos no Rails, agora quando você persistir seu objeto ele ira gravar a data e a hora, e toda as vezes que você atualizar esse objeto no banco de dados ele irá atualizar a data e hora do campo updated, como na imagem a abaixo:

Bom pessoal esse post foi rápido e espero que tenha sido bom.

Até Logo.

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.

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

Esse post tem como objetivo que o pessoal que ta participando do #SouDev deixe seu comentário para que eu possa ir adicionando aqui no post e com isso poder compilar opiniões de todos sobre a campanha, e até discutir formas de ampliar ela, quem sabe até um blog

Então pessoas, o que vocês pensam do #SouDev ?