Lab4

Notas de Última Hora

Documentação das classes nativas de Ruby (Hashes, Arrays, Strings, Ranges, etc)
Documentação das classes da biblioteca Standard (Test::Unit, IO de rede, etc)
Documentação do test/unit de Ruby

Objetivo e Motivação

Introduzir a linguagem Ruby. Portar a última versão do lab 2 para Ruby.

Desenvolvimento

1. Instale o interpretador de Ruby. Instalador para Windows. Para outros SOs procure aqui.
2. Porte o lab, incluindo código de testes.

Observações:

• Não é necessário portar a interface gráfica, para aqueles que utilizaram uma. Crie uma interface simples utilizando linha de comando. Os mais aventureiros que mesmo assim quiserem fazer uma interface gráfica podem tentar:
  • Utilizar JRuby (interpretador de Ruby que roda em Java e tem interoperabilidade com a linguagem), implementando a interface gráfica em Java Swing e utilizando as classes feitas em Ruby.
  • Utilizar o Ruby Tk (biblioteca multiplataforma bem simples e fácil de usar). Outro tutorial.
  • Utilizar o Shoes.
• Organize o código da forma que preferir. Sugestão: 3 arquivos (um para classes, outro para o simulador, e outro para os testes.
• Os métodos setters e getters devem ser convertidos para a convenção de Ruby ( setPropriedade(Object obj) -> propriedade=(obj) e getPropriedade() -> propriedade())
• Use attr_accessor, attr_reader e attr_writter para criar getters e setters simples.

Lendo do console

Basta usar o método global gets, que lê uma string até que o usuário pressione enter. O método retorna a string digitada, incluindo o caractere de nova linha.

string = gets()
int = string.to_i  #converte o string para inteiro
float = string.to_f  #converte o string para float

Tratando exceções em Ruby

As exceções em Ruby nunca precisam ser obrigatoriamente tratadas. No mais o mecanismo de exceções é semelhante a Java.

Hierarquia das Classes de Exceções

Exception
       fatal (used internally by Ruby)
       NoMemoryError
       ScriptError
           LoadError
           NotImplementedError
           SyntaxError
       SignalException
           Interrupt
       StandardError
           ArgumentError
           IOError
                EOFError
           IndexError
           LocalJumpError
           NameError
                NoMethodError
           RangeError
                FloatDomainError
           RegexpError
           RuntimeError
           SecurityError
           SystemCallError
                system-dependent exceptions (Errno::xxx)
           ThreadError
           TypeError
           ZeroDivisionError
       SystemExit
       SystemStackError

Tratanto exceções:

begin 
  #codigo
rescue Exception => e
   #código que trata exceção
   #objeto da classe exceção disponível em "e"
end
 
#outros exemplos
begin
  eval string  #pega o que tem na string e executa como código em Ruby
rescue SyntaxError, NameError => boom
  #trata dois tipos de erro
  print "String doesn't compile: " + boom
rescue StandardError => bang
  print "Error running script: " + bang
rescue
  #trata qualquer tipo (que não foi tratado nas linhas anteriores)
ensure
   # equivalente ao finally de java - executa sempre 
   puts "Terminei!"
end
 
# para tratar todas as exceções dentro de um método não é 
# necessário utilizar o begin .. end, pode-se colocar o rescue 
# diretamente no corpo do método
def metodo_que_trata_excecao
  f = File.open("arquivo.txt")
rescue IOError
  # entra aqui se houver erro de leitura
  puts "Erro!!!"
end

Diferentemente de Java, não é necessário instanciar a classe para lançar a exceção. Gerando exceções:

raise "um erro genérico" # exceção do tipo  Exception com mensagem especificada
raise ArgumentError  # exceção do tipo ArgumentError
raise NameError, "Uma mensagem customizada de erro". # exceção do tipo NameError com mensagem customizada de erro

Código de Testes

Vocês devem portar também todo o código de testes do lab 2. Exemplo de uma classe de testes, com estrutura bem semelhante a do JUnit em Java:

testes.rb:

require 'minhas_classes' #carregue o código da sua aplicação aqui
require 'test/unit'
#este é só um exemplo, não é toda a classe de testes!
class TestInteressante < Test::Unit::TestCase
  def test_meu_teste
    queue = RelaQueue.new
    aluno = AlunoITA("John Smith", queue)
    aluno.comportamento = SafoPreguicoso.new(aluno)
    assert_equal(1.0, aluno.inteligencia(), 0.01)
    assert_true(aluno.dedicacao() < 0.5)
    assert_raise(Exception) { aluno.comportamento = Burro(aluno) }  # passa um bloco de código
                                                                                            #que é executado e deve gerar exceção
  end
end

Basta executar este código com o interpretador para verificar se os testes passam.

ruby testes.rb

Relatório

Foque em explicitar as diferenças entre as linguagens dinâmicas (Ruby) e as estáticas, no que diz respeito aos conceitos de OO aprendidos. Avalie as diferenças entre o tamanho e legibilidade do código das duas aplicações. Descreva as dificuldades que encontrou. Diga o que gostou e o que não gostou na linguagem Ruby. Para mostrar a execução do código e testes, cole screenshots.