├── .cairn ├── .gitignore ├── README.md ├── _webby ├── Sitefile ├── content │ ├── acucares-sintaticos-do-ruby.txt │ ├── arrays-ruby.txt │ ├── blocos-ruby.txt │ ├── caracteristicas.txt │ ├── classe-time-do-ruby.txt │ ├── classes-abertas-em-ruby.txt │ ├── constantes.txt │ ├── construcoes-simples.txt │ ├── controle-de-acesso.txt │ ├── css │ │ ├── blueprint │ │ │ ├── ie.css │ │ │ ├── plugins │ │ │ │ ├── buttons │ │ │ │ │ ├── icons │ │ │ │ │ │ ├── cross.png │ │ │ │ │ │ ├── key.png │ │ │ │ │ │ └── tick.png │ │ │ │ │ ├── readme.txt │ │ │ │ │ └── screen.css │ │ │ │ ├── fancy-type │ │ │ │ │ ├── readme.txt │ │ │ │ │ └── screen.css │ │ │ │ ├── link-icons │ │ │ │ │ ├── icons │ │ │ │ │ │ ├── doc.png │ │ │ │ │ │ ├── email.png │ │ │ │ │ │ ├── external.png │ │ │ │ │ │ ├── feed.png │ │ │ │ │ │ ├── im.png │ │ │ │ │ │ ├── pdf.png │ │ │ │ │ │ ├── visited.png │ │ │ │ │ │ └── xls.png │ │ │ │ │ ├── readme.txt │ │ │ │ │ └── screen.css │ │ │ │ └── rtl │ │ │ │ │ ├── readme.txt │ │ │ │ │ └── screen.css │ │ │ ├── print.css │ │ │ ├── screen.css │ │ │ └── src │ │ │ │ ├── forms.css │ │ │ │ ├── grid.css │ │ │ │ ├── grid.png │ │ │ │ ├── ie.css │ │ │ │ ├── print.css │ │ │ │ ├── reset.css │ │ │ │ └── typography.css │ │ ├── coderay.css │ │ └── site.css │ ├── diversao-com-strings.txt │ ├── duck-typing.txt │ ├── escopo.txt │ ├── escrevendo-seus-metodos.txt │ ├── escrevendo-sua-propria-classe.txt │ ├── excecoes.txt │ ├── expressoes-regulares.txt │ ├── hashes-ruby.txt │ ├── heranca.txt │ ├── images │ │ ├── exception.jpg │ │ ├── hierarquia_classes.gif │ │ ├── logo_guru-sp.jpg │ │ └── operators.jpg │ ├── incluindo-outros-arquivos.txt │ ├── index.txt │ ├── ler-escrever-arquivos.txt │ ├── logging-com-ruby.txt │ ├── mais-sobre-metodos.txt │ ├── mais-sobre-strings.txt │ ├── modulos-mixins.txt │ ├── nomes-em-ruby.txt │ ├── numeros-aleatorios.txt │ ├── numeros-em-ruby.txt │ ├── objetos-mutaveis-e-imutaveis.txt │ ├── primeiro-programa-ruby.txt │ ├── procs.txt │ ├── recebendo-entrada.txt │ ├── ruby-method-missing.txt │ ├── ruby-ri.txt │ ├── self.txt │ ├── serializacao-de-objetos.txt │ ├── series.txt │ ├── simbolos.txt │ ├── sobrecarregando-metodos.txt │ ├── sobreposicao-de-metodos.txt │ ├── sumario-ruby1.txt │ ├── sumario-ruby2.txt │ ├── sumario-ruby3.txt │ ├── sumario-ruby4.txt │ ├── sumario-ruby5.txt │ ├── sumario-ruby6.txt │ ├── sumario-ruby7.txt │ ├── sumario-ruby8.txt │ └── variaveis-e-atribuicao.txt ├── layouts │ └── default.txt ├── lib │ ├── breadcrumbs.rb │ ├── index.txt │ ├── override.rb │ └── pagination.rb ├── tasks │ └── github_pages.rake └── templates │ ├── _partial.erb │ └── page.erb ├── acucares-sintaticos-do-ruby.html ├── arrays-ruby.html ├── blocos-ruby.html ├── caracteristicas.html ├── classe-time-do-ruby.html ├── classes-abertas-em-ruby.html ├── constantes.html ├── construcoes-simples.html ├── controle-de-acesso.html ├── css ├── blueprint │ ├── ie.css │ ├── plugins │ │ ├── buttons │ │ │ ├── icons │ │ │ │ ├── cross.png │ │ │ │ ├── key.png │ │ │ │ └── tick.png │ │ │ ├── readme.txt │ │ │ └── screen.css │ │ ├── fancy-type │ │ │ ├── readme.txt │ │ │ └── screen.css │ │ ├── link-icons │ │ │ ├── icons │ │ │ │ ├── doc.png │ │ │ │ ├── email.png │ │ │ │ ├── external.png │ │ │ │ ├── feed.png │ │ │ │ ├── im.png │ │ │ │ ├── pdf.png │ │ │ │ ├── visited.png │ │ │ │ └── xls.png │ │ │ ├── readme.txt │ │ │ └── screen.css │ │ └── rtl │ │ │ ├── readme.txt │ │ │ └── screen.css │ ├── print.css │ ├── screen.css │ └── src │ │ ├── forms.css │ │ ├── grid.css │ │ ├── grid.png │ │ ├── ie.css │ │ ├── print.css │ │ ├── reset.css │ │ └── typography.css ├── coderay.css └── site.css ├── diversao-com-strings.html ├── duck-typing.html ├── escopo.html ├── escrevendo-seus-metodos.html ├── escrevendo-sua-propria-classe.html ├── excecoes.html ├── expressoes-regulares.html ├── hashes-ruby.html ├── heranca.html ├── images ├── exception.jpg ├── hierarquia_classes.gif ├── logo_guru-sp.jpg └── operators.jpg ├── incluindo-outros-arquivos.html ├── index.html ├── ler-escrever-arquivos.html ├── logging-com-ruby.html ├── mais-sobre-metodos.html ├── mais-sobre-strings.html ├── modulos-mixins.html ├── nomes-em-ruby.html ├── numeros-aleatorios.html ├── numeros-em-ruby.html ├── objetos-mutaveis-e-imutaveis.html ├── primeiro-programa-ruby.html ├── procs.html ├── recebendo-entrada.html ├── ruby-method-missing.html ├── ruby-ri.html ├── self.html ├── serializacao-de-objetos.html ├── series.html ├── simbolos.html ├── sobrecarregando-metodos.html ├── sobreposicao-de-metodos.html ├── sumario-ruby1.html ├── sumario-ruby2.html ├── sumario-ruby3.html ├── sumario-ruby4.html ├── sumario-ruby5.html ├── sumario-ruby6.html ├── sumario-ruby7.html ├── sumario-ruby8.html └── variaveis-e-atribuicao.html /.cairn: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/.cairn -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | *.sw? 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ### Tradução tutorial do Rubylearning.com ### 2 | 3 | Esse tutorial é uma uma tradução parcial do tutorial do Satish Talim, que é utilizando no Rubylearning.org 4 | 5 | O tutorial original pode ser encontrado aqui: 6 | http://rubylearning.com/satishtalim/tutorial.html 7 | 8 | O tutorial gerado por esse projeto está hospedado no Github Pages na seguinte URL: 9 | http://guru-sp.github.com/tutorial_ruby/ 10 | 11 | ### Contribuições 12 | 13 | O tutorial está aberto a contribuições: 14 | - melhorias na tradução; 15 | - correções de grafia; 16 | - conteúdo do tutorial e exemplos 17 | 18 | 19 | ### Estruturação do Tutoral 20 | 21 | O tutorial conta com dois branches: 22 | 23 | - master - Onde está este README 24 | - gh-pages - Onde fica o tutorial propriamente dito (código HTML, figuras e CSS) 25 | 26 | No branch gh-pages você encontra a seguinte estrutura de pastas: 27 | 28 | .cairn 29 | _webby/ 30 | css/ 31 | images/ 32 | index.html 33 | 34 | Esse projeto usa a gem webby para gerar suas páginas HTML. 35 | 36 | Você deve editar somente o conteúdo da pasta _webby e dentro dela executar o comando "webby" que gerará as páginas HTML, arquivos CSS e imagens com as alterações feitas. 37 | 38 | Para mais informações de como usar o webby acesse: http://webby.rubyforge.org/tutorial/. 39 | 40 | Qualquer dúvida, entre na lista do Guru-SP e pergunte! 41 | -------------------------------------------------------------------------------- /_webby/Sitefile: -------------------------------------------------------------------------------- 1 | SITE.output_dir = '..' 2 | 3 | task :default => :clean_build 4 | 5 | #desc 'deploy the site to the webserver' 6 | #task :deploy => [:build, 'deploy:rsync'] 7 | 8 | # EOF 9 | -------------------------------------------------------------------------------- /_webby/content/acucares-sintaticos-do-ruby.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Açúcares sintáticos do Ruby 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Programadores utilizam o termo açúcares sintáticos para se referir a regras especiais, que permitem que você escreva seu código de uma maneira que não correspondem as regras normais, mais que seja mais fácil de lembrar como fazer e fica melhor. 11 | 12 | Vamos dizer que queremos definir o nome de um cachorro. Como ponto de partida, o nome pode ser definido junto com tudo, mais em tempo de criação do objeto, como no exemplo abaixo. 13 | 14 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 15 | class NewDog 16 | def initialize(breed, name) 17 | @breed = breed 18 | @name = name 19 | end 20 | attr_reader :breed, :name # Apenas para leitura 21 | end 22 | nd = NewDog.new('Doberman', 'Benzy') 23 | puts nd.name 24 | <% end -%> 25 | 26 | Vamos reescrever o método set_name, que nos permite definir ou redefinir o nome de um cachorro existente. Também vamos rescrever o método initialize para que ele não espere um nome: 27 | 28 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 29 | class NewDog 30 | def initialize(breed) 31 | @breed = breed 32 | end 33 | attr_reader :breed, :name # Apenas para leitura 34 | # método setter 35 | def set_name(nm) 36 | @name = nm 37 | end 38 | end 39 | nd = NewDog.new('Doberman') 40 | nd.set_name('Benzy') 41 | puts nd.name 42 | <% end -%> 43 | 44 | 45 | Ruby permite que você defina métodos que terminam com um sinal de igual (=). Vamos substituir set_name com um método chamado name= 46 | 47 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 48 | def name=(nm) 49 | @name = nm 50 | end 51 | <% end -%> 52 | 53 | 54 | name= faz exatamente o que set_name faz e apesar do nome do método um pouco estranho, você pode chamá-lo como qualquer outro método: 55 | 56 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 57 | nd.name=('Benzy') 58 | <% end -%> 59 | 60 | 61 | Exemplo - p050newdog.rb 62 | 63 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 64 | class NewDog 65 | def initialize(breed) 66 | @breed = breed 67 | end 68 | attr_reader :breed, :name # Apenas para leitura 69 | 70 | # método setter 71 | def name=(nm) 72 | @name = nm 73 | end 74 | end 75 | 76 | nd = NewDog.new('Doberman') 77 | #nd.name=('Benzy') 78 | nd.name = 'Benzy' 79 | puts nd.name 80 | <% end -%> 81 | 82 | 83 | O sinal de igual lhe dá algo que você conhece como "atribui um valor a algo", assim você sabe que esta lidando com um método setter. Ele ainda parece estranho, mais Ruby cuida de tudo. 84 | 85 | Ruby lhe da um pouco de açucares sintático para chamar métodos setter. 86 | 87 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 88 | nd.name=('Benzy') 89 | <% end -%> 90 | 91 | 92 | você tem permissão para fazer isso: 93 | 94 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 95 | nd.name = 'Benzy' 96 | <% end -%> 97 | 98 | Quando o interpretador vê a mensagem "name" seguido de "=", ele automaticamente ignora os espaços antes do sinal de igual e lê a mensagem como única, "name=" - Uma chamada para o método cujo nome é name=, o que nós definimos. Quanto ao lado direito: os parênteses são opcionais para métodos com argumentos simples, sendo assim, você pode colocar apenas 'Benzy' lá e ele vai ser pego como argumento para o método name=. 99 | 100 |
101 | NO RAILS: Chamadas de métodos usando sinal de igual são comuns em aplicações Rails. 102 |
103 | 104 | <%- page_title, page_url = next_page %> 105 | 106 | 107 | -------------------------------------------------------------------------------- /_webby/content/caracteristicas.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Características 3 | created_at: 2009-05-23 19:38:34.298532 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Algumas características do Ruby são: 11 | 12 | # *Formato livre* - Você pode começar escrevendo seu programa de qualquer linha ou coluna. 13 | # *Case sensitive* - Letras maiúsculas e minúsculas são distintas. A palavra chave *end*, por exemplo, é completamente diferente da palavra chave *END*. 14 | # *Comentários* - Qualquer coisa a partir de um *#* (fora de aspas), até o final da linha onde ele aparece, é ignorado pelo interpretador. Para facilitar grandes blocos de comentários, o interpretador do Ruby também ignora qualquer coisa entre uma linha começando com *=begin* e outra linha começando com *=end*. Isto só funciona se o sinal de = é o primeiro caractere em cada linha. 15 | # *Delimitadores de instruções* - Múltiplas instruções em uma mesma linha deve ser separadas por ponto e vírgula, mas eles não são requeridos no final da linha; quebras de linha são tratadas como ponto e vírgula. Se uma linha termina com uma barra invertida (\), a quebra de linha seguinte é ignorada; isso permite a você ter uma única linha lógica distribuída em diversas linhas. 16 | # *Palavras chaves* - Também conhecidas como palavras reservadas (por volta de 41 delas) em Ruby elas tipicamente não podem ser usadas para outros propósitos. Além dessas palavras chaves, existem 3 símbolos que são tratados especialmente pelo analisador do Ruby quando eles aparecem no início de uma linha: *=begin*, *=end*, *_END_* Você pode estar acostumado a pensar que um valor falso pode ser representado como um zero, uma string nula, um caractere nulo, ou várias outras coisas. Mas em Ruby, todos esses são verdadeiros, tudo é verdadeiro exceto as palavras reservadas *false* e *nil*. Palavras chaves seriam chamadas "palavras reservadas" na maioria das linguagens e nunca seriam permitidas como identificadores. O analisador Ruby é flexível e não reclama se você adicionar a essas palavras chaves os prefixos @, @@ ou $ e utilizar elas como nomes de variáveis de instância, de classe ou globais. A boa prática é tratar essas palavras chaves como reservadas. 17 | # *Codificação de programa* - Em um baixo nível, um programa Ruby é simplesmente uma sequência de caracteres. As "regras léxicas":http://pt.wikipedia.org/wiki/An%C3%A1lise_l%C3%A9xica do Ruby são definidas utilizando caracteres do conjunto de caracteres ASCII. Todas as palavras chaves do Ruby são escritas utilizando caracteres ASCII, todos os operadores e outras pontuações são desenhadas com o conjunto de caracteres ASCII. 18 | 19 |
Documentação - A "documentação completa do Ruby está disponível online aqui (em inglês)":http://www.ruby-doc.org. "O Ruby Cheat Sheet está disponível aqui (em inglês)":http://cheat.errtheblog.com. O instalador de Ruby para Windows também vem com "fxri - Ajuda e console interativo de Ruby":o_que_e_ruby.html.
20 | 21 | <%- page_title, page_url = next_page %> 22 | 23 | 24 | -------------------------------------------------------------------------------- /_webby/content/classe-time-do-ruby.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: A classe Time do Ruby 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | A classe **Time** do Ruby tem uma poderosa função de formatação que pode lhe ajudar a representar horários e datas de diversas formas. A classe time contém uma interface do Ruby para um conjunto de funções de tempo escritas em C. O tempo zero para Ruby é o primeiro segundo GMT de primeiro de janeiro de 1970. A classe **DateTime** é superior a classe Time para aplicações históricas e astronômicas mas você pode usar **Time** para a maior parte dos programas do dia-a-dia. 11 | 12 | A função strftime é modelada seguindo a função printf do C. O programa **p042time.rb** mostra algumas dessas funções. 13 | 14 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 15 | t = Time.now 16 | # para obter o dia, mês e ano com o século 17 | # também a hora, minuto e segundo 18 | puts t.strftime("%d/%m/%Y %H:%M:%S") 19 | 20 | # Você pode usar A e B maiúsculos para obter 21 | # o nome completo do dia da semana e do mês, respectivamente 22 | puts t.strftime("%A") 23 | puts t.strftime("%B") 24 | 25 | # Você pode usar a e b minúsculos para obter 26 | # o nome abreviado do dia da semana e do mês, respectivamente 27 | puts t.strftime("%a") 28 | puts t.strftime("%b") 29 | 30 | # relógio de 24 horas e nome do fuso-horário da hora 31 | puts t.strftime("at %H:%M %Z") 32 | <% end -%> 33 | 34 | A saída é: 35 | 36 | <% coderay(:lang => "bash", :line_numbers => "inline") do -%> 37 | >ruby p042time.rb 38 | 10/09/2006 10:06:31 39 | Sunday 40 | September 41 | Sun 42 | Sep 43 | at 10:06 India Standard Time 44 | >Exit code: 0 45 | <% end -%> 46 | 47 | h2. Sumário 48 | 49 | Listei "todos os pontos importantes":sumario-ruby6.html que você precisa se lembrar após ter completado os seguintes tópicos: Controle de Acesso, Exceções, Logging e classe de tempo do Ruby. 50 | 51 | <%- page_title, page_url = next_page %> 52 | 53 | 54 | -------------------------------------------------------------------------------- /_webby/content/classes-abertas-em-ruby.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Classes abertas em Ruby" 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 |
11 | No Ruby as classes nunca são fechadas: você pode sempre adicionar métodos a uma classe existente. Isso se aplica para classes que você escreve assim como para as classes padrões que vem com a linguagem. Tudo o que você tem que fazer é abrir a definição de uma classe existente e então o conteúdo será adicionado a mesma. 12 |
13 | 14 | Veja o programa **p031motorcycletest.rb** do último tópico, e adicione o método mostraAttr 15 | 16 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 17 | require 'p030motorcycle' 18 | m = MotoCicleta.new('Yamaha', 'vermelha') 19 | m.ligaMotor 20 | 21 | class MotoCicleta 22 | def mostraAttr 23 | puts 'A cor da Motocicleta é ' + @cor 24 | puts 'O fabricante da Motocicleta é ' + @fabricante 25 | end 26 | end 27 | m.mostraAttr 28 | m.ligaMotor 29 | puts self.class 30 | puts self 31 | <% end -%> 32 | 33 | Perceba que self.class se refere a **Object** e self se refere a um objeto chamado main da classe **Object**. 34 | 35 | Mais um exemplo é o programa - **p031xdognext.rb** 36 | 37 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 38 | require 'p029dog' 39 | # define a classe Cachorro 40 | class Cachorro 41 | def late_alto 42 | puts 'AU! AU!' 43 | end 44 | end 45 | # cria um objeto 46 | d = Cachorro.new('Labrador', 'Benzy') 47 | d.late 48 | d.late_alto 49 | d.display 50 | <% end -%> 51 | 52 | Aqui está outro exemplo de se adicionar um método para a classe **String**. O programa **p032mystring.rb** ilustra o mesmo. Veja que o método que adicionamos não faz nada de novo, apenas chama o método **size**. Em um cenário real você adicionaria uma funcionalidade nova a String. 53 | 54 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 55 | class String 56 | def escreve_tamanho 57 | self.size 58 | end 59 | end 60 | escritor_de_tamanho = "Conte-me meu tamanho!" 61 | puts escritor_de_tamanho.escreve_tamanho 62 | <% end -%> 63 | 64 | (Você pode conferir a saída para os programas acima por conta própria). 65 | 66 |
67 | Se você está escrevendo um novo método que conceitualmente pertence a classe original, você pode reabrir a classe e adicionar seu método a definição da mesma. Você deve apenas fazer isso se seu método tem utilidade genérica e você tem certeza que ele não entrará em conflito com um outro método definido por uma biblioteca que você pode incluir no futuro. Se o seu método não tem utilidade genérica, ou você não quer correr o risco de modificar uma classe após sua criação, crie uma subclasse da classe original. A subclasse pode sobrescrever seus métodos pais, ou adicionar novos. Isso é mais seguro porque a classe original e, qualquer código que dependa dela, não serão afetados. 68 |
69 | 70 | <%- page_title, page_url = next_page %> 71 | 72 | 73 | -------------------------------------------------------------------------------- /_webby/content/constantes.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Constantes 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Uma constante Ruby é como uma variável, exceto que seu valor supostamente deve se manter constante enquanto o programa durar. O interpretador Ruby na verdade não força a constância de constantes, mas ele avisa caso um programa altere o valor de uma constante, como mostrado nesse exemplo trivial - **p054constwarn.rb** 11 | 12 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 13 | # p054constwarn.rb 14 | A_CONST = 10 15 | A_CONST = 20 16 | <% end -%> 17 | 18 | Produz um aviso (warning): 19 | 20 | <% coderay(:lang => "bash", :line_numbers => "inline") do -%> 21 | p054constwarn.rb:3: warning: already initialized constant A_CONST 22 | # aviso: a constante A_CONST já foi inicializada 23 | <% end -%> 24 | 25 | Do ponto de vista léxico, o nome de constantes se parece com o de variáveis locais, exceto pelo fato de começarem uma letra em maiúsculo. Por convenção, a maioria das constantes são escritas com todas as letras em maiúsculas e underscores são usados para separar palavras, DESSA_FORMA. Os nomes de módulo e de classes Ruby são também constantes, mas são convencionalmente escritos usando letras maiúsculas no início de cada palavra (o chamado camel case), AssimPorExemplo. 26 | 27 | Perceba que constantes não existem até que um valor seja associado as mesmas. 28 | 29 | Embora constantes não devam ser alteradas, você pode modificar o estado interno dos objetos que elas referenciam, como visto no exemplo **p055constalter.rb**: 30 | 31 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 32 | # p055constalter.rb 33 | A_CONST = "Doshi" 34 | B_CONST = A_CONST 35 | A_CONST[0] = "J" # altera a string referenciada pela constante 36 | puts A_CONST # mostra Joshi 37 | puts B_CONST # também mostra Joshi 38 | <% end -%> 39 | 40 |
41 | NO RAILS: Você pode encontrar exemplos desse tipo de operação (modificação) no código fonte do Rails, onde constantes aparecem prominentemente e os objetos que elas representam passam por mudanças com certa frequência. 42 |
43 | 44 | Observe: 45 | * Constantes definidas dento de uma classe ou módulo podem ser acessadas em qualquer lugar dentro da classe ou módulo 46 | * Fora da classe ou módulo, elas podem ser acessadas usando o operador de escopo :: , prefixado por uma expressão que retorna o módulo ou classe associado (Classe::CONSTANTE) 47 | * Constantes definidas fora de qualquer classe ou módulo podem ser acessadas normalmente ou usando o operador de escopo sem nenhum prefixo. 48 | * Constantes não podem ser definidas em métodos. 49 | * Constantes podem ser externamente adicionadas a classes e módulos existentes utilizando o nome da classe ou do módulo e o operador de escopo antes do nome da constante. 50 | 51 | O programa **p056const.rb** mostra tudo isso: 52 | 53 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 54 | CONSTANTE_EXTERNA = 99 55 | 56 | class Constante 57 | def pega_constante 58 | CONSTANTE 59 | end 60 | CONSTANTE = CONSTANTE_EXTERNA + 1 61 | end 62 | 63 | puts Constante.new.pega_constante 64 | puts Constante::CONSTANTE 65 | puts ::CONSTANTE_EXTERNA 66 | puts Constante::NOVA_CONSTANTE = 123 67 | <% end -%> 68 | 69 | Outro exemplo elaborado sobre métodos de uma classe é o **p057mymethods2.rb**. Nesse exemplo nós também vemos como escrever um método de classe. 70 | 71 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 72 | # p057mymethods2.rb 73 | # variávais e métodos começam com letra minúscula 74 | $glob = 5 # variáveis globais começam com $ 75 | class TestVar # nome de classe é constante, começa com maiúscula 76 | @@cla = 6 # variáveis de classe começam com @@ 77 | CONST_VAL = 7 # estilo de constante, caixa alta, underscore 78 | def initialize(x) # construtor 79 | @inst = x # variáveis de instância começam com @ 80 | @@cla += 1 # cada objeto compartilha @@cla 81 | end 82 | def self.cla # método de classe, getter 83 | @@cla 84 | end 85 | def self.cla=(y) # método de classe, setter, também TestVar. 86 | @@cla = y 87 | end 88 | def inst # método de instância, getter 89 | @inst 90 | end 91 | def inst=(i) # método de instância, setter 92 | @inst = i 93 | end 94 | end 95 | puts $glob 96 | test = TestVar.new(3) # chama construtor 97 | puts TestVar.cla # chma getter 98 | puts test.inspect # dá o ID do objeto e variáveis de instância 99 | TestVar.cla = 4 # chama setter 100 | test.inst=8 # chama setter 101 | puts TestVar.cla 102 | puts test.inst # chama getter 103 | other = TestVar.new(17) 104 | puts other.inspect 105 | puts TestVar.cla 106 | <% end -%> 107 | 108 | h2. Sumário 109 | 110 | Listei todos os "pontos importantes":sumario-ruby8.html que você precisa se lembrar após ter completado os seguintes tópicos: Serialização de Objetos, Módulos/Mixins, Self e Constantes. 111 | 112 | <%- page_title, page_url = next_page %> 113 | 114 | 115 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/ie.css: -------------------------------------------------------------------------------- 1 | /* ----------------------------------------------------------------------- 2 | 3 | 4 | Blueprint CSS Framework 0.8 5 | http://blueprintcss.org 6 | 7 | * Copyright (c) 2007-Present. See LICENSE for more info. 8 | * See README for instructions on how to use Blueprint. 9 | * For credits and origins, see AUTHORS. 10 | * This is a compressed file. See the sources in the 'src' directory. 11 | 12 | ----------------------------------------------------------------------- */ 13 | 14 | /* ie.css */ 15 | body {text-align:center;} 16 | .container {text-align:left;} 17 | * html .column, * html div.span-1, * html div.span-2, * html div.span-3, * html div.span-4, * html div.span-5, * html div.span-6, * html div.span-7, * html div.span-8, * html div.span-9, * html div.span-10, * html div.span-11, * html div.span-12, * html div.span-13, * html div.span-14, * html div.span-15, * html div.span-16, * html div.span-17, * html div.span-18, * html div.span-19, * html div.span-20, * html div.span-21, * html div.span-22, * html div.span-23, * html div.span-24 {overflow-x:hidden;} 18 | * html legend {margin:-18px -8px 16px 0;padding:0;} 19 | ol {margin-left:2em;} 20 | sup {vertical-align:text-top;} 21 | sub {vertical-align:text-bottom;} 22 | html>body p code {*white-space:normal;} 23 | hr {margin:-8px auto 11px;} 24 | .clearfix, .container {display:inline-block;} 25 | * html .clearfix, * html .container {height:1%;} 26 | fieldset {padding-top:0;} -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/buttons/icons/cross.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/buttons/icons/cross.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/buttons/icons/key.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/buttons/icons/key.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/buttons/icons/tick.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/buttons/icons/tick.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/buttons/readme.txt: -------------------------------------------------------------------------------- 1 | Buttons 2 | 3 | * Gives you great looking CSS buttons, for both and 25 | 26 | 27 | Change Password 28 | 29 | 30 | 31 | Cancel 32 | 33 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/buttons/screen.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | buttons.css 4 | * Gives you some great CSS-only buttons. 5 | 6 | Created by Kevin Hale [particletree.com] 7 | * particletree.com/features/rediscovering-the-button-element 8 | 9 | See Readme.txt in this folder for instructions. 10 | 11 | -------------------------------------------------------------- */ 12 | 13 | a.button, button { 14 | display:block; 15 | float:left; 16 | margin: 0.7em 0.5em 0.7em 0; 17 | padding:5px 10px 5px 7px; /* Links */ 18 | 19 | border:1px solid #dedede; 20 | border-top:1px solid #eee; 21 | border-left:1px solid #eee; 22 | 23 | background-color:#f5f5f5; 24 | font-family:"Lucida Grande", Tahoma, Arial, Verdana, sans-serif; 25 | font-size:100%; 26 | line-height:130%; 27 | text-decoration:none; 28 | font-weight:bold; 29 | color:#565656; 30 | cursor:pointer; 31 | } 32 | button { 33 | width:auto; 34 | overflow:visible; 35 | padding:4px 10px 3px 7px; /* IE6 */ 36 | } 37 | button[type] { 38 | padding:4px 10px 4px 7px; /* Firefox */ 39 | line-height:17px; /* Safari */ 40 | } 41 | *:first-child+html button[type] { 42 | padding:4px 10px 3px 7px; /* IE7 */ 43 | } 44 | button img, a.button img{ 45 | margin:0 3px -3px 0 !important; 46 | padding:0; 47 | border:none; 48 | width:16px; 49 | height:16px; 50 | float:none; 51 | } 52 | 53 | 54 | /* Button colors 55 | -------------------------------------------------------------- */ 56 | 57 | /* Standard */ 58 | button:hover, a.button:hover{ 59 | background-color:#dff4ff; 60 | border:1px solid #c2e1ef; 61 | color:#336699; 62 | } 63 | a.button:active{ 64 | background-color:#6299c5; 65 | border:1px solid #6299c5; 66 | color:#fff; 67 | } 68 | 69 | /* Positive */ 70 | body .positive { 71 | color:#529214; 72 | } 73 | a.positive:hover, button.positive:hover { 74 | background-color:#E6EFC2; 75 | border:1px solid #C6D880; 76 | color:#529214; 77 | } 78 | a.positive:active { 79 | background-color:#529214; 80 | border:1px solid #529214; 81 | color:#fff; 82 | } 83 | 84 | /* Negative */ 85 | body .negative { 86 | color:#d12f19; 87 | } 88 | a.negative:hover, button.negative:hover { 89 | background:#fbe3e4; 90 | border:1px solid #fbc2c4; 91 | color:#d12f19; 92 | } 93 | a.negative:active { 94 | background-color:#d12f19; 95 | border:1px solid #d12f19; 96 | color:#fff; 97 | } 98 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/fancy-type/readme.txt: -------------------------------------------------------------------------------- 1 | Fancy Type 2 | 3 | * Gives you classes to use if you'd like some 4 | extra fancy typography. 5 | 6 | Credits and instructions are specified above each class 7 | in the fancy-type.css file in this directory. 8 | 9 | 10 | Usage 11 | ---------------------------------------------------------------- 12 | 13 | 1) Add this plugin to lib/settings.yml. 14 | See compress.rb for instructions. 15 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/fancy-type/screen.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | fancy-type.css 4 | * Lots of pretty advanced classes for manipulating text. 5 | 6 | See the Readme file in this folder for additional instructions. 7 | 8 | -------------------------------------------------------------- */ 9 | 10 | /* Indentation instead of line shifts for sibling paragraphs. */ 11 | p + p { text-indent:2em; margin-top:-1.5em; } 12 | form p + p { text-indent: 0; } /* Don't want this in forms. */ 13 | 14 | 15 | /* For great looking type, use this code instead of asdf: 16 | asdf 17 | Best used on prepositions and ampersands. */ 18 | 19 | .alt { 20 | color: #666; 21 | font-family: "Warnock Pro", "Goudy Old Style","Palatino","Book Antiqua", Georgia, serif; 22 | font-style: italic; 23 | font-weight: normal; 24 | } 25 | 26 | 27 | /* For great looking quote marks in titles, replace "asdf" with: 28 | “asdf” 29 | (That is, when the title starts with a quote mark). 30 | (You may have to change this value depending on your font size). */ 31 | 32 | .dquo { margin-left: -.5em; } 33 | 34 | 35 | /* Reduced size type with incremental leading 36 | (http://www.markboulton.co.uk/journal/comments/incremental_leading/) 37 | 38 | This could be used for side notes. For smaller type, you don't necessarily want to 39 | follow the 1.5x vertical rhythm -- the line-height is too much. 40 | 41 | Using this class, it reduces your font size and line-height so that for 42 | every four lines of normal sized type, there is five lines of the sidenote. eg: 43 | 44 | New type size in em's: 45 | 10px (wanted side note size) / 12px (existing base size) = 0.8333 (new type size in ems) 46 | 47 | New line-height value: 48 | 12px x 1.5 = 18px (old line-height) 49 | 18px x 4 = 72px 50 | 72px / 5 = 14.4px (new line height) 51 | 14.4px / 10px = 1.44 (new line height in em's) */ 52 | 53 | p.incr, .incr p { 54 | font-size: 10px; 55 | line-height: 1.44em; 56 | margin-bottom: 1.5em; 57 | } 58 | 59 | 60 | /* Surround uppercase words and abbreviations with this class. 61 | Based on work by Jørgen Arnor Gårdsø Lom [http://twistedintellect.com/] */ 62 | 63 | .caps { 64 | font-variant: small-caps; 65 | letter-spacing: 1px; 66 | text-transform: lowercase; 67 | font-size:1.2em; 68 | line-height:1%; 69 | font-weight:bold; 70 | padding:0 2px; 71 | } 72 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/icons/doc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/link-icons/icons/doc.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/icons/email.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/link-icons/icons/email.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/icons/external.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/link-icons/icons/external.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/icons/feed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/link-icons/icons/feed.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/icons/im.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/link-icons/icons/im.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/icons/pdf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/link-icons/icons/pdf.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/icons/visited.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/link-icons/icons/visited.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/icons/xls.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/plugins/link-icons/icons/xls.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/readme.txt: -------------------------------------------------------------------------------- 1 | Link Icons 2 | * Icons for links based on protocol or file type. 3 | 4 | This is not supported in IE versions < 7. 5 | 6 | 7 | Credits 8 | ---------------------------------------------------------------- 9 | 10 | * Marc Morgan 11 | * Olav Bjorkoy [bjorkoy.com] 12 | 13 | 14 | Usage 15 | ---------------------------------------------------------------- 16 | 17 | 1) Add this line to your HTML: 18 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/link-icons/screen.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | link-icons.css 4 | * Icons for links based on protocol or file type. 5 | 6 | See the Readme file in this folder for additional instructions. 7 | 8 | -------------------------------------------------------------- */ 9 | 10 | /* Use this class if a link gets an icon when it shouldn't. */ 11 | body a.noicon { 12 | background:transparent none !important; 13 | padding:0 !important; 14 | margin:0 !important; 15 | } 16 | 17 | /* Make sure the icons are not cut */ 18 | a[href^="http:"], a[href^="mailto:"], a[href^="http:"]:visited, 19 | a[href$=".pdf"], a[href$=".doc"], a[href$=".xls"], a[href$=".rss"], 20 | a[href$=".rdf"], a[href^="aim:"] { 21 | padding:2px 22px 2px 0; 22 | margin:-2px 0; 23 | background-repeat: no-repeat; 24 | background-position: right center; 25 | } 26 | 27 | /* External links */ 28 | a[href^="http:"] { background-image: url(icons/external.png); } 29 | a[href^="mailto:"] { background-image: url(icons/email.png); } 30 | a[href^="http:"]:visited { background-image: url(icons/visited.png); } 31 | 32 | /* Files */ 33 | a[href$=".pdf"] { background-image: url(icons/pdf.png); } 34 | a[href$=".doc"] { background-image: url(icons/doc.png); } 35 | a[href$=".xls"] { background-image: url(icons/xls.png); } 36 | 37 | /* Misc */ 38 | a[href$=".rss"], 39 | a[href$=".rdf"] { background-image: url(icons/feed.png); } 40 | a[href^="aim:"] { background-image: url(icons/im.png); } -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/rtl/readme.txt: -------------------------------------------------------------------------------- 1 | RTL 2 | * Mirrors Blueprint, so it can be used with Right-to-Left languages. 3 | 4 | By Ran Yaniv Hartstein, ranh.co.il 5 | 6 | Usage 7 | ---------------------------------------------------------------- 8 | 9 | 1) Add this line to your HTML: 10 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/plugins/rtl/screen.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | rtl.css 4 | * Mirrors Blueprint for left-to-right languages 5 | 6 | By Ran Yaniv Hartstein [ranh.co.il] 7 | 8 | -------------------------------------------------------------- */ 9 | 10 | body .container { direction: rtl; } 11 | body .column { 12 | float: right; 13 | margin-right: 0; 14 | margin-left: 10px; 15 | } 16 | 17 | body .last { margin-left: 0; } 18 | body table .last { padding-left: 0; } 19 | 20 | body .append-1 { padding-right: 0; padding-left: 40px; } 21 | body .append-2 { padding-right: 0; padding-left: 80px; } 22 | body .append-3 { padding-right: 0; padding-left: 120px; } 23 | body .append-4 { padding-right: 0; padding-left: 160px; } 24 | body .append-5 { padding-right: 0; padding-left: 200px; } 25 | body .append-6 { padding-right: 0; padding-left: 240px; } 26 | body .append-7 { padding-right: 0; padding-left: 280px; } 27 | body .append-8 { padding-right: 0; padding-left: 320px; } 28 | body .append-9 { padding-right: 0; padding-left: 360px; } 29 | body .append-10 { padding-right: 0; padding-left: 400px; } 30 | body .append-11 { padding-right: 0; padding-left: 440px; } 31 | body .append-12 { padding-right: 0; padding-left: 480px; } 32 | body .append-13 { padding-right: 0; padding-left: 520px; } 33 | body .append-14 { padding-right: 0; padding-left: 560px; } 34 | body .append-15 { padding-right: 0; padding-left: 600px; } 35 | body .append-16 { padding-right: 0; padding-left: 640px; } 36 | body .append-17 { padding-right: 0; padding-left: 680px; } 37 | body .append-18 { padding-right: 0; padding-left: 720px; } 38 | body .append-19 { padding-right: 0; padding-left: 760px; } 39 | body .append-20 { padding-right: 0; padding-left: 800px; } 40 | body .append-21 { padding-right: 0; padding-left: 840px; } 41 | body .append-22 { padding-right: 0; padding-left: 880px; } 42 | body .append-23 { padding-right: 0; padding-left: 920px; } 43 | 44 | body .prepend-1 { padding-left: 0; padding-right: 40px; } 45 | body .prepend-2 { padding-left: 0; padding-right: 80px; } 46 | body .prepend-3 { padding-left: 0; padding-right: 120px; } 47 | body .prepend-4 { padding-left: 0; padding-right: 160px; } 48 | body .prepend-5 { padding-left: 0; padding-right: 200px; } 49 | body .prepend-6 { padding-left: 0; padding-right: 240px; } 50 | body .prepend-7 { padding-left: 0; padding-right: 280px; } 51 | body .prepend-8 { padding-left: 0; padding-right: 320px; } 52 | body .prepend-9 { padding-left: 0; padding-right: 360px; } 53 | body .prepend-10 { padding-left: 0; padding-right: 400px; } 54 | body .prepend-11 { padding-left: 0; padding-right: 440px; } 55 | body .prepend-12 { padding-left: 0; padding-right: 480px; } 56 | body .prepend-13 { padding-left: 0; padding-right: 520px; } 57 | body .prepend-14 { padding-left: 0; padding-right: 560px; } 58 | body .prepend-15 { padding-left: 0; padding-right: 600px; } 59 | body .prepend-16 { padding-left: 0; padding-right: 640px; } 60 | body .prepend-17 { padding-left: 0; padding-right: 680px; } 61 | body .prepend-18 { padding-left: 0; padding-right: 720px; } 62 | body .prepend-19 { padding-left: 0; padding-right: 760px; } 63 | body .prepend-20 { padding-left: 0; padding-right: 800px; } 64 | body .prepend-21 { padding-left: 0; padding-right: 840px; } 65 | body .prepend-22 { padding-left: 0; padding-right: 880px; } 66 | body .prepend-23 { padding-left: 0; padding-right: 920px; } 67 | 68 | body .border { 69 | padding-right: 0; 70 | padding-left: 4px; 71 | margin-right: 0; 72 | margin-left: 5px; 73 | border-right: none; 74 | border-left: 1px solid #eee; 75 | } 76 | 77 | body .colborder { 78 | padding-right: 0; 79 | padding-left: 24px; 80 | margin-right: 0; 81 | margin-left: 25px; 82 | border-right: none; 83 | border-left: 1px solid #eee; 84 | } 85 | 86 | body .pull-1 { margin-left: 0; margin-right: -40px; } 87 | body .pull-2 { margin-left: 0; margin-right: -80px; } 88 | body .pull-3 { margin-left: 0; margin-right: -120px; } 89 | body .pull-4 { margin-left: 0; margin-right: -160px; } 90 | 91 | body .push-0 { margin: 0 18px 0 0; } 92 | body .push-1 { margin: 0 18px 0 -40px; } 93 | body .push-2 { margin: 0 18px 0 -80px; } 94 | body .push-3 { margin: 0 18px 0 -120px; } 95 | body .push-4 { margin: 0 18px 0 -160px; } 96 | body .push-0, body .push-1, body .push-2, 97 | body .push-3, body .push-4 { float: left; } 98 | 99 | 100 | /* Typography with RTL support */ 101 | body h1,body h2,body h3, 102 | body h4,body h5,body h6 { font-family: Arial, sans-serif; } 103 | html body { font-family: Arial, sans-serif; } 104 | body pre,body code,body tt { font-family: monospace; } 105 | 106 | /* Mirror floats and margins on typographic elements */ 107 | body p img { float: right; margin: 1.5em 0 1.5em 1.5em; } 108 | body dd, body ul, body ol { margin-left: 0; margin-right: 1.5em;} 109 | body td, body th { text-align:right; } -------------------------------------------------------------------------------- /_webby/content/css/blueprint/print.css: -------------------------------------------------------------------------------- 1 | /* ----------------------------------------------------------------------- 2 | 3 | 4 | Blueprint CSS Framework 0.8 5 | http://blueprintcss.org 6 | 7 | * Copyright (c) 2007-Present. See LICENSE for more info. 8 | * See README for instructions on how to use Blueprint. 9 | * For credits and origins, see AUTHORS. 10 | * This is a compressed file. See the sources in the 'src' directory. 11 | 12 | ----------------------------------------------------------------------- */ 13 | 14 | /* print.css */ 15 | body {line-height:1.5;font-family:Helvetica,Arial,sans-serif;color:#000;background:none;font-size:10pt;} 16 | .container {background:none;} 17 | hr {background:#ccc;color:#ccc;width:100%;height:2px;margin:2em 0;padding:0;border:none;} 18 | hr.space {background:#fff;color:#fff;} 19 | h1, h2, h3, h4, h5, h6 {font-family:"Helvetica Neue", Arial, "Lucida Grande", sans-serif;} 20 | code {font:.9em "Courier New", Monaco, Courier, monospace;} 21 | img {float:left;margin:1.5em 1.5em 1.5em 0;} 22 | a img {border:none;} 23 | p img.top {margin-top:0;} 24 | blockquote {margin:1.5em;padding:1em;font-style:italic;font-size:.9em;} 25 | .small {font-size:.9em;} 26 | .large {font-size:1.1em;} 27 | .quiet {color:#999;} 28 | .hide {display:none;} 29 | a:link, a:visited {background:transparent;font-weight:700;text-decoration:underline;} 30 | a:link:after, a:visited:after {content:" (" attr(href) ") ";font-size:90%;} 31 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/src/forms.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | forms.css 4 | * Sets up some default styling for forms 5 | * Gives you classes to enhance your forms 6 | 7 | Usage: 8 | * For text fields, use class .title or .text 9 | 10 | -------------------------------------------------------------- */ 11 | 12 | label { font-weight: bold; } 13 | fieldset { padding:1.4em; margin: 0 0 1.5em 0; border: 1px solid #ccc; } 14 | legend { font-weight: bold; font-size:1.2em; } 15 | 16 | 17 | /* Form fields 18 | -------------------------------------------------------------- */ 19 | 20 | input.text, input.title, 21 | textarea, select { 22 | margin:0.5em 0; 23 | border:1px solid #bbb; 24 | } 25 | 26 | input.text:focus, input.title:focus, 27 | textarea:focus, select:focus { 28 | border:1px solid #666; 29 | } 30 | 31 | input.text, 32 | input.title { width: 300px; padding:5px; } 33 | input.title { font-size:1.5em; } 34 | textarea { width: 390px; height: 250px; padding:5px; } 35 | 36 | 37 | /* Success, notice and error boxes 38 | -------------------------------------------------------------- */ 39 | 40 | .error, 41 | .notice, 42 | .success { padding: .8em; margin-bottom: 1em; border: 2px solid #ddd; } 43 | 44 | .error { background: #FBE3E4; color: #8a1f11; border-color: #FBC2C4; } 45 | .notice { background: #FFF6BF; color: #514721; border-color: #FFD324; } 46 | .success { background: #E6EFC2; color: #264409; border-color: #C6D880; } 47 | .error a { color: #8a1f11; } 48 | .notice a { color: #514721; } 49 | .success a { color: #264409; } 50 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/src/grid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/css/blueprint/src/grid.png -------------------------------------------------------------------------------- /_webby/content/css/blueprint/src/ie.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | ie.css 4 | 5 | Contains every hack for Internet Explorer, 6 | so that our core files stay sweet and nimble. 7 | 8 | -------------------------------------------------------------- */ 9 | 10 | /* Make sure the layout is centered in IE5 */ 11 | body { text-align: center; } 12 | .container { text-align: left; } 13 | 14 | /* Fixes IE margin bugs */ 15 | * html .column, * html div.span-1, * html div.span-2, 16 | * html div.span-3, * html div.span-4, * html div.span-5, 17 | * html div.span-6, * html div.span-7, * html div.span-8, 18 | * html div.span-9, * html div.span-10, * html div.span-11, 19 | * html div.span-12, * html div.span-13, * html div.span-14, 20 | * html div.span-15, * html div.span-16, * html div.span-17, 21 | * html div.span-18, * html div.span-19, * html div.span-20, 22 | * html div.span-21, * html div.span-22, * html div.span-23, 23 | * html div.span-24 { overflow-x: hidden; } 24 | 25 | 26 | /* Elements 27 | -------------------------------------------------------------- */ 28 | 29 | /* Fixes incorrect styling of legend in IE6. */ 30 | * html legend { margin:-18px -8px 16px 0; padding:0; } 31 | 32 | /* Fixes incorrect placement of ol numbers in IE6/7. */ 33 | ol { margin-left:2em; } 34 | 35 | /* Fixes wrong line-height on sup/sub in IE. */ 36 | sup { vertical-align: text-top; } 37 | sub { vertical-align: text-bottom; } 38 | 39 | /* Fixes IE7 missing wrapping of code elements. */ 40 | html>body p code { *white-space: normal; } 41 | 42 | /* IE 6&7 has problems with setting proper
margins. */ 43 | hr { margin: -8px auto 11px; } 44 | 45 | 46 | /* Clearing 47 | -------------------------------------------------------------- */ 48 | 49 | /* Makes clearfix actually work in IE */ 50 | .clearfix, .container {display: inline-block;} 51 | * html .clearfix, 52 | * html .container {height: 1%;} 53 | 54 | 55 | /* Forms 56 | -------------------------------------------------------------- */ 57 | 58 | /* Fixes padding on fieldset */ 59 | fieldset {padding-top: 0;} -------------------------------------------------------------------------------- /_webby/content/css/blueprint/src/print.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | print.css 4 | * Gives you some sensible styles for printing pages. 5 | * See Readme file in this directory for further instructions. 6 | 7 | Some additions you'll want to make, customized to your markup: 8 | #header, #footer, #navigation { display:none; } 9 | 10 | -------------------------------------------------------------- */ 11 | 12 | body { 13 | line-height: 1.5; 14 | font-family: "Helvetica Neue", Arial, Helvetica, sans-serif; 15 | color:#000; 16 | background: none; 17 | font-size: 10pt; 18 | } 19 | 20 | 21 | /* Layout 22 | -------------------------------------------------------------- */ 23 | 24 | .container { 25 | background: none; 26 | } 27 | 28 | hr { 29 | background:#ccc; 30 | color:#ccc; 31 | width:100%; 32 | height:2px; 33 | margin:2em 0; 34 | padding:0; 35 | border:none; 36 | } 37 | hr.space { 38 | background: #fff; 39 | color: #fff; 40 | } 41 | 42 | 43 | /* Text 44 | -------------------------------------------------------------- */ 45 | 46 | h1,h2,h3,h4,h5,h6 { font-family: "Helvetica Neue", Arial, "Lucida Grande", sans-serif; } 47 | code { font:.9em "Courier New", Monaco, Courier, monospace; } 48 | 49 | img { float:left; margin:1.5em 1.5em 1.5em 0; } 50 | a img { border:none; } 51 | p img.top { margin-top: 0; } 52 | 53 | blockquote { 54 | margin:1.5em; 55 | padding:1em; 56 | font-style:italic; 57 | font-size:.9em; 58 | } 59 | 60 | .small { font-size: .9em; } 61 | .large { font-size: 1.1em; } 62 | .quiet { color: #999; } 63 | .hide { display:none; } 64 | 65 | 66 | /* Links 67 | -------------------------------------------------------------- */ 68 | 69 | a:link, a:visited { 70 | background: transparent; 71 | font-weight:700; 72 | text-decoration: underline; 73 | } 74 | 75 | a:link:after, a:visited:after { 76 | content: " (" attr(href) ") "; 77 | font-size: 90%; 78 | } 79 | 80 | /* If you're having trouble printing relative links, uncomment and customize this: 81 | (note: This is valid CSS3, but it still won't go through the W3C CSS Validator) */ 82 | 83 | /* a[href^="/"]:after { 84 | content: " (http://www.yourdomain.com" attr(href) ") "; 85 | } */ 86 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/src/reset.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | reset.css 4 | * Resets default browser CSS. 5 | 6 | -------------------------------------------------------------- */ 7 | 8 | html, body, div, span, object, iframe, 9 | h1, h2, h3, h4, h5, h6, p, blockquote, pre, 10 | a, abbr, acronym, address, code, 11 | del, dfn, em, img, q, dl, dt, dd, ol, ul, li, 12 | fieldset, form, label, legend, 13 | table, caption, tbody, tfoot, thead, tr, th, td { 14 | margin: 0; 15 | padding: 0; 16 | border: 0; 17 | font-weight: inherit; 18 | font-style: inherit; 19 | font-size: 100%; 20 | font-family: inherit; 21 | vertical-align: baseline; 22 | } 23 | 24 | body { 25 | line-height: 1.5; 26 | } 27 | 28 | /* Tables still need 'cellspacing="0"' in the markup. */ 29 | table { border-collapse: separate; border-spacing: 0; } 30 | caption, th, td { text-align: left; font-weight: normal; } 31 | table, td, th { vertical-align: middle; } 32 | 33 | /* Remove possible quote marks (") from ,
. */ 34 | blockquote:before, blockquote:after, q:before, q:after { content: ""; } 35 | blockquote, q { quotes: "" ""; } 36 | 37 | /* Remove annoying border on linked images. */ 38 | a img { border: none; } 39 | -------------------------------------------------------------------------------- /_webby/content/css/blueprint/src/typography.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | typography.css 4 | * Sets up some sensible default typography. 5 | 6 | -------------------------------------------------------------- */ 7 | 8 | /* Default font settings. 9 | The font-size percentage is of 16px. (0.75 * 16px = 12px) */ 10 | body { 11 | font-size: 75%; 12 | color: #222; 13 | background: #fff; 14 | font-family: "Helvetica Neue", Arial, Helvetica, sans-serif; 15 | } 16 | 17 | 18 | /* Headings 19 | -------------------------------------------------------------- */ 20 | 21 | h1,h2,h3,h4,h5,h6 { font-weight: normal; color: #111; } 22 | 23 | h1 { font-size: 3em; line-height: 1; margin-bottom: 0.5em; } 24 | h2 { font-size: 2em; margin-bottom: 0.75em; } 25 | h3 { font-size: 1.5em; line-height: 1; margin-bottom: 1em; } 26 | h4 { font-size: 1.2em; line-height: 1.25; margin-bottom: 1.25em; } 27 | h5 { font-size: 1em; font-weight: bold; margin-bottom: 1.5em; } 28 | h6 { font-size: 1em; font-weight: bold; } 29 | 30 | h1 img, h2 img, h3 img, 31 | h4 img, h5 img, h6 img { 32 | margin: 0; 33 | } 34 | 35 | 36 | /* Text elements 37 | -------------------------------------------------------------- */ 38 | 39 | p { margin: 0 0 1.5em; } 40 | p img.left { float: left; margin: 1.5em 1.5em 1.5em 0; padding: 0; } 41 | p img.right { float: right; margin: 1.5em 0 1.5em 1.5em; } 42 | 43 | a:focus, 44 | a:hover { color: #000; } 45 | a { color: #009; text-decoration: underline; } 46 | 47 | blockquote { margin: 1.5em; color: #666; font-style: italic; } 48 | strong { font-weight: bold; } 49 | em,dfn { font-style: italic; } 50 | dfn { font-weight: bold; } 51 | sup, sub { line-height: 0; } 52 | 53 | abbr, 54 | acronym { border-bottom: 1px dotted #666; } 55 | address { margin: 0 0 1.5em; font-style: italic; } 56 | del { color:#666; } 57 | 58 | pre { margin: 1.5em 0; white-space: pre; } 59 | pre,code,tt { font: 1em 'andale mono', 'lucida console', monospace; line-height: 1.5; } 60 | 61 | 62 | /* Lists 63 | -------------------------------------------------------------- */ 64 | 65 | li ul, 66 | li ol { margin:0 1.5em; } 67 | ul, ol { margin: 0 1.5em 1.5em 1.5em; } 68 | 69 | ul { list-style-type: disc; } 70 | ol { list-style-type: decimal; } 71 | 72 | dl { margin: 0 0 1.5em 0; } 73 | dl dt { font-weight: bold; } 74 | dd { margin-left: 1.5em;} 75 | 76 | 77 | /* Tables 78 | -------------------------------------------------------------- */ 79 | 80 | table { margin-bottom: 1.4em; width:100%; } 81 | th { font-weight: bold; } 82 | thead th { background: #c3d9ff; } 83 | th,td,caption { padding: 4px 10px 4px 5px; } 84 | tr.even td { background: #e5ecf9; } 85 | tfoot { font-style: italic; } 86 | caption { background: #eee; } 87 | 88 | 89 | /* Misc classes 90 | -------------------------------------------------------------- */ 91 | 92 | .small { font-size: .8em; margin-bottom: 1.875em; line-height: 1.875em; } 93 | .large { font-size: 1.2em; line-height: 2.5em; margin-bottom: 1.25em; } 94 | .hide { display: none; } 95 | 96 | .quiet { color: #666; } 97 | .loud { color: #000; } 98 | .highlight { background:#ff0; } 99 | .added { background:#060; color: #fff; } 100 | .removed { background:#900; color: #fff; } 101 | 102 | .first { margin-left:0; padding-left:0; } 103 | .last { margin-right:0; padding-right:0; } 104 | .top { margin-top:0; padding-top:0; } 105 | .bottom { margin-bottom:0; padding-bottom:0; } 106 | -------------------------------------------------------------------------------- /_webby/content/css/coderay.css: -------------------------------------------------------------------------------- 1 | .CodeRay { 2 | padding: 0.5em; 3 | margin-bottom: 1.3em; 4 | background-color: #eee; 5 | border: 1px solid #aaa; 6 | font: 1.1em "Monaco","Bitstream Vera Sans Mono","Courier New",serif; 7 | color: #100; 8 | } 9 | .CodeRay pre { 10 | padding: 0px; 11 | margin: 0px; 12 | overflow: auto; 13 | background-color: transparent; 14 | border: none; 15 | } 16 | 17 | 18 | div.CodeRay { } 19 | 20 | span.CodeRay { white-space: pre; border: 0px; padding: 2px;} 21 | 22 | table.CodeRay { border-collapse: collapse; width: 100%; padding: 2px } 23 | table.CodeRay td { padding: 2px 4px; vertical-align: top } 24 | 25 | .CodeRay .line_numbers, .CodeRay .no { 26 | background-color: #DDD; 27 | color: #333; 28 | text-align: right; 29 | } 30 | .CodeRay .line_numbers tt { font-weight: bold } 31 | .CodeRay .no { padding: 0px 4px } 32 | 33 | ol.CodeRay { font-size: 10pt } 34 | ol.CodeRay li { white-space: pre } 35 | 36 | .CodeRay .debug { color:white ! important; background:blue ! important; } 37 | 38 | .CodeRay .af { color:#00C } 39 | .CodeRay .an { color:#007 } 40 | .CodeRay .av { color:#700 } 41 | .CodeRay .aw { color:#C00 } 42 | .CodeRay .bi { color:#509; font-weight:bold } 43 | .CodeRay .c { color:#666; } 44 | 45 | .CodeRay .ch { color:#04D } 46 | .CodeRay .ch .k { color:#04D } 47 | .CodeRay .ch .dl { color:#039 } 48 | 49 | .CodeRay .cl { color:#B06; font-weight:bold } 50 | .CodeRay .co { color:#036; font-weight:bold } 51 | .CodeRay .cr { color:#0A0 } 52 | .CodeRay .cv { color:#369 } 53 | .CodeRay .df { color:#099; font-weight:bold } 54 | .CodeRay .di { color:#088; font-weight:bold } 55 | .CodeRay .dl { color:black } 56 | .CodeRay .do { color:#970 } 57 | .CodeRay .ds { color:#D42; font-weight:bold } 58 | .CodeRay .e { color:#666; font-weight:bold } 59 | .CodeRay .en { color:#800; font-weight:bold } 60 | .CodeRay .er { color:#F00; background-color:#FAA } 61 | .CodeRay .ex { color:#F00; font-weight:bold } 62 | .CodeRay .fl { color:#60E; font-weight:bold } 63 | .CodeRay .fu { color:#06B; font-weight:bold } 64 | .CodeRay .gv { color:#d70; font-weight:bold } 65 | .CodeRay .hx { color:#058; font-weight:bold } 66 | .CodeRay .i { color:#00D; font-weight:bold } 67 | .CodeRay .ic { color:#B44; font-weight:bold } 68 | 69 | .CodeRay .il { background: #eee } 70 | .CodeRay .il .il { background: #ddd } 71 | .CodeRay .il .il .il { background: #ccc } 72 | .CodeRay .il .idl { font-weight: bold; color: #888 } 73 | 74 | .CodeRay .in { color:#B2B; font-weight:bold } 75 | .CodeRay .iv { color:#33B } 76 | .CodeRay .la { color:#970; font-weight:bold } 77 | .CodeRay .lv { color:#963 } 78 | .CodeRay .oc { color:#40E; font-weight:bold } 79 | .CodeRay .of { color:#000; font-weight:bold } 80 | .CodeRay .op { } 81 | .CodeRay .pc { color:#038; font-weight:bold } 82 | .CodeRay .pd { color:#369; font-weight:bold } 83 | .CodeRay .pp { color:#579 } 84 | .CodeRay .pt { color:#339; font-weight:bold } 85 | .CodeRay .r { color:#080; font-weight:bold } 86 | 87 | .CodeRay .rx { background-color:#fff0ff } 88 | .CodeRay .rx .k { color:#808 } 89 | .CodeRay .rx .dl { color:#404 } 90 | .CodeRay .rx .mod { color:#C2C } 91 | .CodeRay .rx .fu { color:#404; font-weight: bold } 92 | 93 | .CodeRay .s { background-color:#fff0f0 } 94 | .CodeRay .s .s { background-color:#ffe0e0 } 95 | .CodeRay .s .s .s { background-color:#ffd0d0 } 96 | .CodeRay .s .k { color:#D20 } 97 | .CodeRay .s .dl { color:#710 } 98 | 99 | .CodeRay .sh { background-color:#f0fff0 } 100 | .CodeRay .sh .k { color:#2B2 } 101 | .CodeRay .sh .dl { color:#161 } 102 | 103 | .CodeRay .sy { color:#A60 } 104 | .CodeRay .sy .k { color:#A60 } 105 | .CodeRay .sy .dl { color:#630 } 106 | 107 | .CodeRay .ta { color:#070 } 108 | .CodeRay .tf { color:#070; font-weight:bold } 109 | .CodeRay .ts { color:#D70; font-weight:bold } 110 | .CodeRay .ty { color:#339; font-weight:bold } 111 | .CodeRay .v { color:#036 } 112 | .CodeRay .xt { color:#444 } 113 | -------------------------------------------------------------------------------- /_webby/content/css/site.css: -------------------------------------------------------------------------------- 1 | --- 2 | extension: css 3 | filter: erb 4 | layout: nil # no layout 5 | 6 | color: 7 | border: "#ddd" 8 | header: "#111" 9 | link: "#125AA7" 10 | link-hover: "#000" 11 | blockquote: "#666" 12 | box-bg: "#e0e0e0" 13 | highlight: "#D82925" 14 | quiet: "#666" 15 | alt: "#666" 16 | box-bg-important: "#FFF3CF" 17 | box-bg-important-border: "#FC0" 18 | --- 19 | 20 | body { 21 | font-family: Verdana, "Bitstream Vera Sans", sans-serif; 22 | } 23 | 24 | /* Headings 25 | * --------------------------------------------------------------------- */ 26 | h1,h2,h3,h4,h5,h6 { color: <%= @page.color['header'] %>; } 27 | 28 | /* Text Elements 29 | * --------------------------------------------------------------------- */ 30 | a { color: <%= @page.color['link'] %>; } 31 | a:hover { color: <%= @page.color['link-hover'] %>; } 32 | blockquote { color: <%= @page.color['blockquote'] %>; } 33 | 34 | pre { 35 | background: <%= @page.color['box-bg'] %>; 36 | border: 1px solid <%= @page.color['border'] %>; 37 | } 38 | 39 | hr { 40 | background: <%= @page.color['highlight'] %>; 41 | color: <%= @page.color['highlight'] %>; 42 | } 43 | 44 | /* Tables 45 | * --------------------------------------------------------------------- */ 46 | table { 47 | border-top: 1px solid <%= @page.color['border'] %>; 48 | border-left: 1px solid <%= @page.color['border'] %>; 49 | } 50 | th,td { 51 | border-bottom: 1px solid <%= @page.color['border'] %>; 52 | border-right: 1px solid <%= @page.color['border'] %>; 53 | } 54 | 55 | /* Default Classes 56 | * --------------------------------------------------------------------- */ 57 | p.quiet { color: <%= @page.color['quiet'] %>; } 58 | .alt { color: <%= @page.color['alt'] %>; } 59 | 60 | p.title { 61 | color: #111; 62 | font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; 63 | font-size: 2em; 64 | margin-bottom: 0.75em; 65 | } 66 | 67 | #header .title { 68 | font-size: 3em; 69 | line-height: 1; 70 | margin: 0.5em 0 0.25em 0; } 71 | #header a { 72 | text-decoration: none; 73 | color: #333; 74 | } 75 | 76 | .box { 77 | background: <%= @page.color['box-bg-important'] %>; 78 | margin: 10px 0 10px 0; 79 | padding: 5px 15px 5px 15px; 80 | border: 1px solid <%= @page.color['box-bg-important-border'] %>; 81 | } 82 | 83 | .box p{ 84 | padding: 0; 85 | margin: 5px 0 5px 0; 86 | } 87 | 88 | .pagination { 89 | text-align: right; 90 | padding: 5px; 91 | margin: 5px; 92 | } 93 | 94 | /* EOF */ 95 | -------------------------------------------------------------------------------- /_webby/content/diversao-com-strings.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Diversão com strings 3 | created_at: 2009-05-24 13:56:49.734412 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Literais string são sequências (ou cadeias) de caracteres entre aspas simples ou dupla. '' (duas aspas simples) que não contêm nada dentro delas; nós chamamos de string vazia. Aqui está um programa *p003stringsruby.rb* que explora strings a um certo nível. 11 | 12 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 13 | # p003stringsruby.rb 14 | =begin 15 | Strings Ruby 16 | Em Ruby, strings são mutáveis 17 | =end 18 | 19 | puts "Olá Mundo" 20 | # Pode-se usar " ou ' para strings, mas ' é mais eficiente 21 | puts 'Olá Mundo' 22 | # Concatenação de strings 23 | puts 'Eu gosto de' + ' Ruby' 24 | # Sequência com escape 25 | puts 'It\'s my Ruby' 26 | # Exibe a string 3 vezes 27 | puts 'Olá' * 3 28 | # Definindo uma constante 29 | # Mais sobre constantes depois, aqui 30 | # nomes_em_ruby.html 31 | PI = 3.1416 32 | puts PI 33 | <% end -%> 34 | 35 | 36 |
37 | # Se é passado ao *puts* um objeto que não é uma string, o *puts* chama o método *to_s* deste objeto e imprime a string retornada pelo método. 38 | # Em Ruby, strings são *mutáveis*. Elas podem expandir quando necessário, sem utilizar muito tempo ou memória. O Ruby armazena uma string como uma sequência de caracteres. 39 |
40 | 41 | Vale a pena saber que existe um tipo especial de string que usa acento grave (`) como delimitador de início e fim. Por exemplo: 42 | 43 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 44 | puts `dir` 45 | <% end -%> 46 | 47 | 48 | A string é enviada para o sistema operacional como um comando a ser executado (no exemplo nós estamos enviando o comando dir para o sistema operacional Windows), a saída do comando (dir numa janela de comando exibiria todos os arquivos e subdiretórios de um diretório) é então exibida pelo *puts*. 49 | 50 | No Linux e no Mac, você pode usar, ao invés: 51 | 52 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 53 | puts `ls` 54 | <% end -%> 55 | 56 | Outro modo de executar um processo separado é utilizando o método *system* de *Kernel*. O método executa um comando dado a ele em um sub-processo; ele retorna *true* se o comando for encontrado e executado propriamente. Ele retorna *false* se o comando encerrar com um status de saída diferente de zero, e *nil* se o comando falhar ao executar. Lembre-se, a saída do comando simplesmente irá para o mesmo destino da saída do seu programa. 57 | 58 | 59 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 60 | system("tar xzf teste.tgz") # => true 61 | <% end -%> 62 | 63 | <%- page_title, page_url = next_page %> 64 | 65 | -------------------------------------------------------------------------------- /_webby/content/duck-typing.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Duck Typing" 3 | created_at: 2010-07-07 19:20:01.610313 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Talvez você já tenha notado, que em Ruby não declaramos os tipos de variáveis ou métodos - tudo já é algum tipo de um objeto. Objetos em Ruby (ao contrário dos objetos em outras linguagens orientadas a objeto) podem ser individualmente modificados. Você sempre pode adicionar métodos em um objeto. Em Ruby, o comportamento ou a capacidade de um objeto, pode se diferenciar dos fornecidos pela sua classe. 11 | 12 |
13 | Em Ruby, nós confiamos menos no tipo (ou classe) de um objeto e mais nas suas capacidades. Por isso, Duck Typing (que por ser um termo técnico, não há uma tradução precisa), significa que um tipo de objeto é definido por aquilo que ele pode fazer, não pelo que ele é. Duck Typing refere-se a tendência de Ruby estar menos preocupado com a classe de um objeto e mais preocupado com quais os métodos que podem ser chamados e quais operações podem ser executadas sobre ele. Em Ruby, usaríamos respond_to? ou poderíamos, simplesmente passar um objeto para um método e saberíamos que uma exceção seria levantada, se formos utilizar de forma inadequada. 14 |
15 | 16 | Se um objeto anda como um pato e fala como um pato, então o interpretador Ruby está feliz em tratá-lo como se fosse um pato. 17 | 18 | Considere o seguinte exemplo. 19 | 20 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 21 | # Verificar se o objeto defini o método to_str 22 | puts ('Uma string'.respond_to? :to_str) # => true 23 | puts (Exception.new.respond_to? :to_str) # => false 24 | puts (4.respond_to? :to_str) # => false 25 | <% end -%> 26 | 27 | O exemplo acima é o exemplo mais simples da filosofia Ruby de Duck Typing: se um objeto faz "quack" como um pato (ou age como uma string), basta ir em frente e tratá-lo como um pato (ou uma string). Sempre que possível, você deve tratar objetos de acordo com os métodos que ele possui, ao invés, de definir as classes a partir do que eles herdam ou módulos que incluem. 28 | 29 | Agora, considere as três seguintes classes - Pato, Ganso e PatoDonald. Programa *p036duck.rb* 30 | 31 | h2. Código 32 | 33 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 34 | class Pato 35 | def quack 36 | 'Quack!' 37 | end 38 | 39 | def nadar 40 | 'nadando nadando nadando...' 41 | end 42 | end 43 | 44 | class Ganso 45 | def grasnar 46 | 'Grasnando!' 47 | end 48 | 49 | def nadar 50 | 'Splash splash splash...' 51 | end 52 | end 53 | 54 | class PatoDonald 55 | def quack 56 | play 57 | end 58 | 59 | def play 60 | 'Quack! Sou o Pato Donald!' 61 | end 62 | end 63 | 64 | def faz_quack(pato) 65 | pato.quack 66 | end 67 | puts faz_quack(Pato.new) 68 | puts faz_quack(PatoDonald.new) 69 | 70 | def faz_nadar(duck) 71 | duck.nadar 72 | end 73 | puts faz_nadar(Pato.new) 74 | puts faz_nadar(Ganso.new) 75 | <% end -%> 76 | 77 | Se você consultar o código abaixo: 78 | 79 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 80 | def faz_quack(pato) 81 | pato.quack 82 | end 83 | puts faz_quack(Pato.new) 84 | puts faz_quack(PatoDonald.new) 85 | <% end -%> 86 | 87 | Um método que disse a um Pato para fazer quack funciona quando recebe um PatoDonald, graças ao Duck Typing. O mesmo pode ser observado no seguinte código: 88 | 89 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 90 | def faz_nadar(pato) 91 | pato.nadar 92 | end 93 | puts faz_nadar(Pato.new) 94 | puts faz_nadar(Ganso.new) 95 | <% end -%> 96 | 97 | Quando um método que diz para um Pato nadar recebe um Ganso, ele funciona. 98 | 99 | <%- page_title, page_url = next_page %> 100 | 101 | 102 | -------------------------------------------------------------------------------- /_webby/content/escopo.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Escopo 3 | created_at: 2009-06-11 13:38:05.995268 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Escopo refere-se ao alcance de visibilidade das variáveis. Diferentes tipos de variáveis tem diferentes regras de escopo. Nós estaremos falando principalmente sobre dois tipos: variáveis globais e locais. 11 | 12 | h2. Escopo global e variáveis globais 13 | 14 | Nós estamos começando com o escopo que é utilizado com menos frequência, mas que você precisa ficar ciente que: escopo global significa que cobre todo o programa. O escopo global é desfrutado por variáveis globais. Variáveis globais são distinguidas por começarem com um sinal de dólar ($). Elas são disponíveis em qualquer lugar do programa. Variáveis globais nunca saem do escopo. Entretanto, variáveis globais são utilizadas muito poucas vezes por programadores experientes (exceto, talvez, aquelas que já vem embutidas). 15 | 16 | h2. Variáveis globais embutidas 17 | 18 | O interpretador do Ruby trás um relativamente grande número de variáveis globais inicializadas. Essas variáveis armazenam informações que possuem potencial usabilidade em todo e qualquer lugar em seu programa. Por exemplo, a variável global *$0* contém o nome do arquivo Ruby sendo executado. A global *$:* (dólar seguido de dois pontos) contém os diretórios que compõem o path onde o Ruby busca quando você carrega um arquivo externo. *$$* contém o id do processo no processamento do Ruby. E existem outras. 19 | 20 | h2. Escopo local 21 | 22 | *Nota:* Não se preocupe se você não entender essa parte agora. 23 | Você pode dizer, olhando um programa Ruby, onde o escopo local começa e termina, baseado nas seguintes regras: 24 | 25 | * O nível mais alto (por fora de todas as definições de bloco) tem seu próprio escopo local. 26 | * Cada definição de bloco de classe ou módulo (class, module) tem seu próprio escopo local, mesmo definições de blocos de classes/módulos aninhadas. 27 | * Cada definição de bloco de método (def) tem seu próprio escopo local. 28 | <%- page_title, page_url = next_page %> 29 | 30 | -------------------------------------------------------------------------------- /_webby/content/hashes-ruby.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Hashes (dicionários) 3 | created_at: 2010-03-03 18:40:01.610313 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Hashes (também conhecidos como arrays associativos, mapas ou dicionários) são similares aos arrays a medida que são coleções indexadas de referências a objetos. No entanto, enquanto o o array é indexado por inteiros (semelhante a um índice remissivo), o hash pode ser indexado com objetos de qualquer tipo: strings, expressões regulares e assim por diante. Quando você armazena um valor em um hash, você na verdade fornece dois objetos - o índice (normalmente chamado de chave) e o valor desse índice. É possível recuperar os valores utilizando o índice do hash. Os valores do hash, assim como os índices, podem ser objetos de qualquer tipo. 11 | 12 | O exemplo **040myhash.rb** abaixo cria um hash com literais (strings): uma lista de pares chave => valor entre 13 | 14 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 15 | # p040myhash.rb 16 | h = {'cachorro' => 'canino', 'gato' => 'felino', 17 | 'burro' => 'asinino', 12 => 'dodezino'} 18 | puts h.length # 4 19 | puts h['cachorro'] # 'canino' 20 | puts h 21 | puts h[12] 22 | <% end %> 23 | 24 | A saída do código acima é: 25 | 26 | <% coderay(:lang => "text", :line_numbers => "inline") do -%> 27 | >ruby p040myhash.rb 28 | 4 29 | canino 30 | {"cachorro"=>"canino", "gato"=>"felino", 31 | "burro"=>"asinino", 12=>"dodezino"} 32 | dodezino 33 | >Exit code: 0 34 | <% end %> 35 | 36 |
37 | Caso o programa apresentado no exemplo seja executado no Ruby 1.8 a saída será um pouco diferente. Em todos exemplos estamos utilizando o Ruby 1.9, no qual o hash é apresentado de forma ordenada e igual a sua declaração. Já no Ruby 1.8 a ordenação do hash é diferente da declarada 38 |
39 | 40 | Comparados com arrays, os hashes têm uma vantagem significativa: eles podem usar qualquer objeto como índice. 41 | 42 | Hashes têm um valor padrão. Tal valor é retornado após uma tentativa de acesso a uma chave não existente. Por padrão este valor é **nil**. 43 | 44 | A classe *Hash* tem muitos métodos e você pode consultá-los "aqui":http://railsapi.com/doc/ruby-v1.9/classes/Hash.html (em inglês). 45 | 46 | h2. Usando Símbolos como chaves do Hash 47 | 48 | Ao invés, de utilizar uma string como chave, de preferência pelo uso de um símbolo. Veja o exemplo a seguir no programa *p041symbolhash.rb*. 49 | 50 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 51 | # p041symbolhash.rb 52 | pessoa = Hash.new 53 | pessoa[:apelido] = 'GuruIndiano' 54 | pessoa[:idioma] = 'Marata' 55 | pessoa[:sobrenome] = 'Talim' 56 | puts pessoa[:sobrenome] # Talim 57 | <% end %> 58 | 59 | Outro exemplo *p0411symbolhash.rb*. 60 | 61 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 62 | # p0411symbolhash.rb 63 | h = {:apelido => 'GuruIndiano', :idioma => 'Marata', :sobrenome => 'Talim'} 64 | puts h 65 | <% end %> 66 | 67 | A saída do exemplo acima é: 68 | 69 | <% coderay(:lang => "text", :line_numbers => "inline") do -%> 70 | {:apelido=>"GuruIndiano", :idioma=>"Marata", :sobrenome=>"Talim"} 71 | <% end %> 72 | 73 | Outra maneira de fazer a mesma coisa é mostrada no programa *p0412symbolhash.rb*. 74 | 75 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 76 | # p0412symbolhash.rb 77 | h = {apelido: 'GuruIndiano', idioma: 'Marata', sobrenome: 'Talim'} 78 | puts h 79 | <% end %> 80 | 81 | A saída é: 82 | 83 | <% coderay(:lang => "text", :line_numbers => "inline") do -%> 84 | {:apelido=>"GuruIndiano", :idioma=>"Marata", :sobrenome=>"Talim"} 85 | <% end %> 86 | 87 | Ou seja, exatamente o mesmo que ocorreu na execução do programa **p0411symbolhash.rb**. 88 | 89 |
90 | O último exemplo (**p0412symbolhash.rb**) não funcionará no Ruby 1.8. Ele utiliza uma sintaxe nova para declarar hashes introduzida no Ruby 1.9. 91 |
92 | 93 | 94 | 95 | <%- page_title, page_url = next_page %> 96 | 97 | 98 | -------------------------------------------------------------------------------- /_webby/content/images/exception.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/images/exception.jpg -------------------------------------------------------------------------------- /_webby/content/images/hierarquia_classes.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/images/hierarquia_classes.gif -------------------------------------------------------------------------------- /_webby/content/images/logo_guru-sp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/images/logo_guru-sp.jpg -------------------------------------------------------------------------------- /_webby/content/images/operators.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/_webby/content/images/operators.jpg -------------------------------------------------------------------------------- /_webby/content/incluindo-outros-arquivos.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Incluindo Outros Arquivos 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Ao escrever seus primeiros programas em Ruby, você costuma colocar todo seu código em um único arquivo. Mas, a medida que você cresce como programador Ruby, seus programas também crescerão e em um determinado ponto você perceberá que ter um único arquivo contendo todo o código 11 | não será uma boa ideia. É mais fácil quebrar seu código em grupos lógicos e colocar cada grupo em um arquivo separado. Quando você começa a utilizar múltiplos arquivos, você precisa usar os métodos **require** (requerer) e **load** (carregar) (ambos métodos são "funções" globais definidas no **Kernel**, mas são usadas como palavras-chave da linguagem) que o ajudam a incluir outros arquivos em seu programa. 12 | 13 | O método **load** inclui o arquivo fonte referenciado toda vez que o método é executado: 14 | 15 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 16 | load 'nome_do_arquivo.rb' 17 | <% end -%> 18 | 19 | O mais comumente usado **require** carrega o arquivo dado apenas uma vez: 20 | 21 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 22 | require 'nome_do_arquivo' 23 | <% end -%> 24 | 25 | **require** lhe dá acesso a muitas extensões e bibliotecas de programação empacotadas com a linguagem de programação Ruby - além de um número ainda maior de extensões e bibliotecas escritas independentemente por outros programadores e disponibilizadas para uso com o Ruby. 26 | 27 | Note que quando você escreve **require** 'nome_do_arquivo' e não 'nome_do_arquivo.rb'. Especificamente, extensões escritas em C são armazenadas em arquivos terminados por .so ou .dll. Para manter o processo transparante - isso é, para lhe poupar o trabalho de saber qual a extensão do arquivo que você quer usar (.rb e etc) - o método aceita uma palavra e então faz uma busca automática tentando todos os nomes de arquivo possíveis até que encontra o arquivo correspondente a extensão que você requisitou. 28 | 29 |
30 | require(string) => true or false 31 | 32 | O Ruby tenta carregar a biblioteca chamada string, retornando true (verdadeiro) em caso de sucesso. Se o nome do arquivo não for resolvido para um caminho absoluto, ele será procurado nos diretórios listados em **$:**. Se o arquivo tem a extensão ".rb", ele é carregado como um arquivo fonte; se a extensão for ".so", ".o" ou ".dll", ou qualquer que seja a extensão de bibliotecas compartilhadas na plataforma em questão, o Ruby carregará a biblioteca compartilhada como uma extensão Ruby. Em caso contrário, o Ruby tenta adicionar ".rb", ".so" e assim por diante ao nome do arquivo. O nome do novo recurso é adicionado ao array em **$:**. 33 |
34 | 35 |
36 | NO RAILS: O Rails usa **load** ao invés de **require**, por exemplo, no modo de desenvolvimento - o que significa que se você está testando sua aplicação em um navegador e fazendo mudanças no código ao mesmo tempo, suas mudanças serão recarregadas, sobrescrevendo qualquer comportamento de caching por parte do servidor Web. Múltiplas chamadas a **require** no mesmo lugar não tem o mesmo efeito se a aplicação já leu o arquivo por completo. 37 |
38 | 39 | Agora, vamos olhar para o exemplo de outra classe - p030motorcycle.rb 40 | 41 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 42 | class MotoCicleta 43 | def initialize(fabricante, cor) 44 | # Variáveis de instância 45 | @fabricante = fabricante 46 | @cor = cor 47 | end 48 | def ligaMotor 49 | if (@estado_motor) 50 | puts 'O motor já está ligado' 51 | else 52 | @estado_motor = true 53 | puts 'Motor ocioso' 54 | end 55 | end 56 | end 57 | <% end -%> 58 | 59 | Escrevemos outro programa **p031motorcycletest.rb** para testar a classe acima. 60 | 61 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 62 | # p031motorcycletest.rb 63 | require 'p030motorcycle' 64 | m = MotoCicleta.new('Yamaha', 'vermelha') 65 | m.ligaMotor 66 | <% end -%> 67 | 68 | A partir da versão 1.9 do Ruby, é usado **require_relative** quando o local onde está o arquivo que desejamos carregar é relativo ao do arquivo que o está carregando (eles estão no mesmo diretório). 69 | 70 | <%- page_title, page_url = next_page %> 71 | 72 | 73 | -------------------------------------------------------------------------------- /_webby/content/index.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Ruby - Mais um tutorial?" 3 | created_at: 2009-04-23 21:39:00.000000 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= @page.title %> 9 | 10 | Este é mais um tutorial de Ruby, idealizado pelos membros do "GURU-SP":http://www.gurusp.org (Grupo de Usuários Ruby de SP) e traduzido entre 2010-2011. Apesar de existir uma grande quantidade de material relacionado a Ruby em língua portuguesa espalhados em blogs, livros, screencasts e tutoriais, acreditamos que há espaço para mais um bom tutorial que sirva como referência para aprender algumas particularidades desta linguagem de programação. 11 | 12 | Nosso tutorial é baseado no material de Satish Talim do "Ruby Learning":http://www.rubylearning.com. Sinta-se a vontade para corrigir erros encontrados, adicionar informações e novos tópicos fazendo um fork do "projeto no github":http://github.com/guru-sp/tutorial_ruby. 13 | 14 | 15 | h2. Índice 16 | 17 | h3. Parte 1 18 | # "Primeiro programa Ruby":primeiro-programa-ruby.html 19 | # "Características":caracteristicas.html 20 | # "Números em Ruby":numeros-em-ruby.html 21 | ## Operadores e precedência 22 | ## Diferença entre os operadores or e || 23 | # "Diversão com Strings":diversao-com-strings.html 24 | # "Variáveis e atribuição":variaveis-e-atribuicao.html 25 | # "Resumo 1":sumario-ruby1.html 26 | 27 | h3. Parte 2 28 | # "Escopo":escopo.html 29 | ## Escopo global e variáveis globais 30 | ## Variáveis globais embutidas 31 | ## Escopo local 32 | # "Recebendo entrada":recebendo-entrada.html 33 | # "Nomes em Ruby":nomes-em-ruby.html 34 | # "Mais sobre métodos Ruby":mais-sobre-metodos.html 35 | # "Escrevendo seus métodos Ruby":escrevendo-seus-metodos.html 36 | ## Métodos 'bang' (!) 37 | ## Métodos terminados por ? 38 | # "Resumo 2":sumario-ruby2.html 39 | 40 | h3. Parte 3 41 | # "A ferramente ri do Ruby":ruby-ri.html 42 | # "Mais sobre Strings":mais-sobre-strings.html 43 | ## Listando todos os métodos de uma classe ou objeto 44 | ## Comparando duas strings para a igualdade 45 | ## Usando %w 46 | # "Construções simples":construcoes-simples.html 47 | ## Condicional ?: 48 | ## Modificadores de atribuição 49 | ## Expressões case 50 | ## nil é um Object 51 | ## Algumas informações extras 52 | # "Blocos em Ruby":blocos-ruby.html 53 | # "Resumo 3":sumario-ruby3.html 54 | 55 | h3. Parte 4 56 | # "Arrays Ruby":arrays-ruby.html 57 | ## Atribuição paralela 58 | ## Variáveis de ambiente 59 | ## Argumentos de linha de comando 60 | ## Biblioteca GetoptLong 61 | # "Séries (Ranges)":series.html 62 | # "Símbolos em Ruby":simbolos.html 63 | # "Hashes (dicionários)":hashes-ruby.html 64 | ## Usando símbolos como chaves hash 65 | # "Números aleatórios":numeros-aleatorios.html 66 | # "Lendo e escrevendo em arquivos":ler-escrever-arquivos.html 67 | ## Varrendo árvores de diretórios 68 | ## Acesso aleatório 69 | # "Resumo 4":sumario-ruby4.html 70 | 71 | h3. Parte 5 72 | # "Expressões Regulares":expressoes-regulares.html 73 | ## Caracteres literais 74 | ## O caractere coringa .(ponto) 75 | ## Classes de caracteres 76 | ## Sequências de escape especial para caracteres de classe comuns 77 | # "Escrevendo sua própria classe":escrevendo-sua-propria-classe.html 78 | ## Construtores literais 79 | ## Coletor de Lixo (Garbage Collection) 80 | ## Métodos de Classe 81 | # "Ruby method missing (método faltando)":ruby-method-missing.html 82 | # "Procs em Ruby":procs.html 83 | # "Incluindo Outros Arquivos":incluindo-outros-arquivos.html 84 | # "Classes Abertas em Ruby":classes-abertas-em-ruby.html 85 | # "Herança":heranca.html 86 | ## Herança e variáveis de instância 87 | # "Sobreposição (Overriding) de Métodos":sobreposicao-de-metodos.html 88 | ## Uso do super 89 | ## Redefinindo métodos 90 | ## Classe abstrata 91 | # "Sobrecarregando métodos em Ruby":sobrecarregando-metodos.html 92 | # "Resumo 5":sumario-ruby5.html 93 | 94 | h3. Parte 6 95 | # "Controle de Acesso":controle-de-acesso.html 96 | ## Sobrepondo métodos privados 97 | ## Métodos acessores 98 | ## Métodos de nível alto 99 | ## Variáveis de instância são herdadas por uma subclasse? 100 | # "Exceções":excecoes.html 101 | ## Lançando uma exceção 102 | ## Tratando uma exceção 103 | ## Exemplo de validação 104 | # "Logging com Ruby":logging-com-ruby.html 105 | # "A classe Time do Ruby":classe-time-do-ruby.html 106 | # "Resumo 6":sumario-ruby6.html 107 | 108 | h3. Parte 7 109 | # "Duck Typing":duck-typing.html 110 | # "Açúcares sintáticos do Ruby":acucares-sintaticos-do-ruby.html 111 | # "Objetos mutáveis e imutáveis":objetos-mutaveis-e-imutaveis.html 112 | ## Congelando objetos 113 | ## Frozen? (congelado) 114 | # "Resumo 7":sumario-ruby7.html 115 | 116 | h3. Parte 8 117 | # "Serialização de objetos":serializacao-de-objetos.html 118 | # "Módulos / Mixins":modulos-mixins.html 119 | # "Self":self.html 120 | ## Contexto do nível superior 121 | ## Self dentro de definições de classes e módulos 122 | ## Self na definição de métodos de instância 123 | ## Self na definição de métodos singleton e métodos de classe 124 | # "Constantes":constantes.html 125 | # "Resumo 8":sumario-ruby8.html 126 | 127 | -------------------------------------------------------------------------------- /_webby/content/logging-com-ruby.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Logging com Ruby 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | A classe **Logger** da biblioteca padrão do Ruby ajuda a escrever mensagens de log para um arquivo ou para um stream de dados. Ela suporta rolagem dos arquivos de log por tempo ou baseada em tamanho. Às mensagens podem ser associados níveis de gravidade e apenas as mensagens em um determinado nivel ou acima do nível atual do logger serão armazenadas, isto é, "logadas". 11 | 12 | Quando você escreve um código, você simplesmente assume que todas as mensagens serão logadas. Em tempo de execução, você pode obter um log mais ou menos verboso mudando o nível do log. Uma aplicação em produção geralmente tem um nível de log Logger:INFO ou Logger:WARN. Do menos ao mais severo, os métodos são **Logger.debug**, **Logger.info**, **Logger.warn**, **Logger.error** e **Logger.fatal**. 13 | 14 | O nível de log DEBUG é útil para diagnosticar uma tarefa passo a passo. O nível ERROR é geralmente usado quando se lida com o tratamento de exceções: se o programa não consegue resolver um problema, ele loga a exceção ao invés de parar sua execução e esperar que um administrador cuide do problema. O nível FATAL deve apenas ser usado quando um programa não pode se recuperar de algum problema, e está prestes a travar ou finalizar. 15 | 16 | Se seu log está sendo armazenado em um arquivo, você pode ter o **Logger** rotacionado ou substituído quando ele se torna muito grande, ou uma vez que uma certa quantidade de tempo passou: 17 | 18 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 19 | require 'logger' 20 | # Mantenha os dados apenas para o mês atual 21 | Logger.new('este_mes_.log', 'monthly') 22 | # Mantenha os dados de hoje e para os proximos 20 dias 23 | Logger.new('application.log', 20, 'daily') 24 | # Reinicia o logger assim que o arquivo completar 100 megabytes 25 | Logger.new('application.log', 0, 100 * 1024 * 1024) 26 | <% end -%> 27 | 28 | O código abaixo, usa o logger da aplicação para imprimir uma mensagem de debugging e, em um nível mais alto de severidade, como parte do código de tratamento de erro. 29 | 30 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 31 | #logex.rb 32 | require 'logger' 33 | $LOG = Logger.new('log_file.log', 'monthly') 34 | def divide(numerador, denominador) 35 | $LOG.debug("Numerator: #{numerador}, denominador #{denominador}") 36 | begin 37 | result = numerador / denominador 38 | rescue Exception => e 39 | $LOG.error "Erro na divisão!: #{e}" 40 | resultado = nil 41 | end 42 | return resultado 43 | end 44 | divide(10, 2) 45 | <% end -%> 46 | 47 | O conteúdo do arquivo log_file.log é: 48 | 49 | <% coderay(:lang => "text", :line_numbers => "inline") do -%> 50 | # Logfile created on Tue Mar 18 17:09:29 +0530 2008 by / 51 | D, [2008-03-18T17:09:29.216000 #2020] DEBUG -- : Numerador: 10, denominador 2 52 | <% end -%> 53 | 54 | 55 | Agora tente chamar o método assim: 56 | 57 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 58 | divide(10, 0) 59 | <% end -%> 60 | 61 | O conteúdo do arquivo log_file.log é: 62 | 63 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 64 | # Logfile created on Tue Mar 18 17:09:29 +0530 2008 by / 65 | D, [2008-03-18T17:09:29.216000 #2020] DEBUG -- : Numerador: 10, denominador 2 66 | D, [2008-03-18T17:13:50.044000 #2820] DEBUG -- : Numerador: 10, denominador 0 67 | E, [2008-03-18T17:13:50.044000 #2820] ERROR -- : Erro na divisião!: divided by 0 68 | <% end -%> 69 | 70 | Para alterar o nível do log, simplesmente associe a constante apropriada a **level**: 71 | 72 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 73 | $LOG.level = Logger::ERROR 74 | <% end -%> 75 | 76 | 77 | Agora nosso logger ignorará todas as mensagens de log exceto as com nível de severidade ERROR ou FATAL. O conteúdo do arquivo log_file.log é: 78 | 79 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 80 | E, [2008-03-18T17:15:59.919000 #2624] ERROR -- : Erro na divisão!: divided by 0 81 | <% end -%> 82 | 83 | <%- page_title, page_url = next_page %> 84 | 85 | 86 | -------------------------------------------------------------------------------- /_webby/content/mais-sobre-metodos.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Mais sobre métodos Ruby 3 | created_at: 2009-07-06 22:48:49.814161 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Se objetos (como strings, inteiros ou floats) são os substantivos na linguagem Ruby, então os métodos são os verbos. Cada método precisa de um objeto. Geralmente é comum dizer qual objeto está executando o método: é o que vem logo antes do ponto. Às vezes, porém, não é tão óbvio assim. Quando estamos usando *puts*, *gets* - onde estão os objetos deles? Em Ruby, o objeto implícito é qualquer objeto em que você está no momento. Mas nós nem sabemos ainda como estar em um objeto; Nós sempre estivemos dentro de um objeto especial (*main*). Ruby o criou para nós e ele representa todo o programa. Você pode sempre ver em que objeto está (objeto corrente) usando a variável especial *self*. 11 | 12 | <% coderay(:lang => "ruby", :line_numbers => "inline") do %> puts self <% end %> 13 | 14 | "Para mais detalhes sobre *self*, veja aqui":self.html. 15 | <%- page_title, page_url = next_page %> 16 | 17 | 18 | -------------------------------------------------------------------------------- /_webby/content/numeros-aleatorios.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Números aleatórios 3 | created_at: 2010-03-10 12:04:30.370531 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | O Ruby vem com um gerador de números aleatórios (ou randômicos). O meio de se obter um número escolhido aleatóriamente é o **rand**. Se você chamar **rand** terá um float maior que ou igual a 0.0 e menor que 1.0. Se você der a ele um parâmetro inteiro (chamando, por exemplo, rand(5)), você obterá um valor inteiro maior que ou igual a 0 e menor que 5. 11 | 12 | Aqui está um exemplo: **p026phrase.rb** 13 | 14 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 15 | # p026phrase.rb 16 | =begin 17 | Se você chamar **rand** terá um float maior que 18 | ou igual a 0.0 e menor que 1.0. Se você der a ele 19 | um parâmetro inteiro (chamando, por exemplo, rand(5)), 20 | você obterá um valor inteiro maior que ou igual a 0 21 | e menor que 5 22 | =end 23 | 24 | # O programa abaixo faz três listas de palavras e 25 | # então escolhe aleatoriamente uma palavra 26 | # para cada uma das três listas e imprime o resultado 27 | 28 | lista_palavras_um = ['24/7', 'multicamada', '30,000 pés', 'B2B', 'win-win', 29 | 'front-end', 'web-based', 'pervasivo', 'inteligente', 30 | 'seis-sigma', 'caminho-crítico', 'dinâmico'] 31 | 32 | lista_palavras_dois = ['empowered', 'sticky', 'value-added', 'orientado', 33 | 'centrado', 'distribuído', 'agrupado', 'branded', 34 | 'fora-da-caixa', 'posicionado', 'em rede', 'focado', 35 | 'alavancado', 'alinhado', 'targeted', 'compartilhado', 36 | 'cooperativo', 'acelerado'] 37 | 38 | lista_palavras_tres = ['processo', 'tipping-point', 'solução', 'arquitetura', 39 | 'competência central', 'estratégia', 'mindshare', 40 | 'portal', 'espaço', 'visão', 'paradigma', 'missão'] 41 | 42 | tamanho_um = lista_palavras_um.length 43 | tamanho_dois = lista_palavras_dois.length 44 | tamanho_tres = lista_palavras_tres.length 45 | 46 | rand1 = rand(tamanho_um) 47 | rand2 = rand(tamanho_dois) 48 | rand3 = rand(tamanho_tres) 49 | 50 | frase = lista_palavras_um[rand1] + " " 51 | + lista_palavras_dois[rand2] + " " + lista_palavras_tres[rand3] 52 | 53 | puts frase 54 | <% end %> 55 | 56 | O programa acima cria três listas de palavras e então seleciona aleatoriamente uma palavra de cada uma das listas e imprime o resultado. 57 | 58 | <%- page_title, page_url = next_page %> 59 | 60 | 61 | -------------------------------------------------------------------------------- /_webby/content/objetos-mutaveis-e-imutaveis.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Objetos mutáveis e imutáveis 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Objetos mutáveis são objetos cujo estado pode mudar. Objetos imutáveis são objetos cujo estado nunca se altera após sua criação. 11 | 12 | Objetos imutáveis têm muitas propriedades desejáveis: 13 | 14 | * Objetos imutáveis são seguros em relação a threads (__thread-safe__). Threads não podem corromper aquilo que não podem alterar. 15 | * Objetos imutáveis tornam mais simples implementar encapsulamento. Se parte do estado de um objeto é armazenado em um objeto imutável, então os métodos assessores podem retornar esse objeto para chamadores externos sem se preocupar se estes chamadores podem mudar o estado do objeto. 16 | * Objetos imutáveis são bons para se usar como chaves hash, visto que seu código hash não pode ser alterado. 17 | 18 | 19 | No Ruby, a mutabilidade é uma propriedade de uma instância, não de uma classe completa. Qualquer instância pode se tornar imutável chamando o método **freeze** (congelar). 20 | 21 | h2. Congelando Objetos 22 | 23 | O método **freeze** na classe **Objetct** previne você de alterar um objeto, efetivamente transformando um objeto em uma constante. Após congelarmos um objeto, uma tentativa de modificá-lo resulta em um erro **RuntimeError**. O programa seguinte **p050xfreeze.rb** ilustra isso: 24 | 25 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 26 | str = 'Uma string simples. ' 27 | str.freeze 28 | begin 29 | str << 'Uma tentativa de se modificar.' 30 | rescue => err 31 | puts "#{err.class} #{err}" 32 | end 33 | # A saída é - TypeError can't modify frozen string 34 | <% end -%> 35 | 36 | 37 | Entretanto, **freeze** opera na referência de um objeto, não em uma variável. Isso significa que qualquer operação resultando em um novo objeto funcionará. Isso pode ser verificado pelo seguinte exemplo: 38 | 39 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 40 | str = 'String original - ' 41 | str.freeze 42 | str += 'anexo' 43 | puts str 44 | # A Saída é - String original - anexo 45 | <% end -%> 46 | 47 | A expressão str += 'anexo' é avaliada para um novo objeto, que é então associado a str. O objeto não é alterado, mas a variável str agora se refere a um novo objeto. 48 | 49 | h2. frozen? (congelado?) 50 | 51 | O método **frozen?** lhe diz se um objeto está congelado ou não. Vamos ver um exemplo: 52 | 53 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 54 | a = b = 'String Original' 55 | b.freeze 56 | puts a.frozen? # true 57 | puts b.frozen? # true 58 | a = 'Nova String' 59 | puts a 60 | puts b 61 | puts a.frozen? # false 62 | puts b.frozen? # true 63 | <% end -%> 64 | 65 | Vamos entender o que estamos fazendo aqui - a e b são duas variáveis que apontam para um objeto do tipo string - __String Original__. 66 | Nós então congelamos o objeto __String Original__. Portanto, tanto a quanto b agora apontam para o objeto congelado __String Original__. Isto é verificado pelas declarações puts a.frozen? e puts b.frozen?. Em seguida, criamos um novo objeto string __Nova String__ e fazemos a variável a apontar para esse novo objeto. A variável b ainda aponta para o objeto congelado e a não mais. Isto é verificado pelas duas últimas declarações do programa. 67 | 68 | **Uso**: 69 | O Ruby às vezes copia objetos e congela as cópias. Quando você usa uma string como chave hash, o Ruby na verdade copia a string, congela a cópia e usa a cópia como chave hash: desse modo, se a string original se alterar mais tarde, a chave hash não é afetada. 70 | 71 | As operações internas de arquivos do Ruby trabalham com uma cópia congelada do nome do arquivo ao invés de usar o nome do arquivo diretamente. Se outra thread altera o nome original do arquivo no meio de uma operação que deveria ser atômica, não há problema: o Ruby não estava usando o nome do arquivo original. Você pode adotar esse padrão copia-e-congela em código com suporte multi-thread para prevenir que uma estrutura de dados com que você esteja trabalhando seja alterada por outra thread. 72 | 73 | Outro uso comum no nível do programador dessa funcionalidade é congelar uma classe para prevenir modificações futuras a mesma. 74 | 75 | **Nota**: Sempre que um objeto no Ruby não tem referência a ele, então o objeto será marcado para remoção e o coletor de lixo irá remover esse objeto baseado em seu algoritmo. Não há como acessar um objeto sem referência. 76 | 77 | 78 | h2. Sumário 79 | 80 | Listei todos os "pontos importantes":sumario-ruby7.html para você se lembrar após ter completado os seguintes tópicos: "Duck Typing":duck-typing.html, "Açúcares sintáticos":acucares-sintaticos-do-ruby.html e Objetos Mutáveis e Imutáveis. 81 | 82 | <%- page_title, page_url = next_page %> 83 | 84 | 85 | -------------------------------------------------------------------------------- /_webby/content/primeiro-programa-ruby.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Primeiro programa Ruby" 3 | created_at: 2009-05-09 16:21:10.285545 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Vamos iniciar o *SciTE*, o editor Ruby que vem com _One Click Ruby Installer_ para Windows. Para isso, em sua área de trabalho clique em _Iniciar/Programas/Ruby-186-25/SciTE_. A janela do editor se abre. Pressione a tecla F8 para abrir uma janela de saída. Agora, clique em _Options/Open Global Options File_ e procure por 'tabsize'. Altere e crie _tabsize=2_ e _indent.size=2_. Eu gosto que a janela do meu *SciTE* esteja maximizada no início e, para isso, configure _position.width=-1_ e _position.height=-1_ Pressione _Ctrl+S_ e _Ctrl+W_. Após isso, pressione _Ctrl+Shift+I_ - isso abrirá a janela de configuração de identação. Aqui, assegure que _Tab Size_ e _Indent Size_ está configurado como 2 e que a opção _Use tabs box_ não está selecionada. Clique em OK. Agora nós estamos prontos para escrever nosso primeiro programa Ruby. 11 | 12 | Crie um diretório, como por exemplo, _programasruby_ em seu C:/ Nós armazenaremos todos os nossos programas neste diretório. Nosso primeiro programa irá exibir a string 'Olá' na janela de comando e o nome do programa será *p001ola.rb* 13 | 14 | Por convenção, arquivos fonte Ruby tem a extensão *.rb*. No Microsoft Windows, arquivos fonte Ruby algumas vezes terminam com .rbw, como em meuscript.rbw. A convenção de codificação Ruby diz que nomes de arquivos/diretórios são escritos em letra minúscula e com extensão .rb. Por exemplo, a classe Foo tem o nome foo.rb 15 | 16 |
O layout do código é por sua conta; o jeito como você escolher indentar não é relevante (mas usando dois caracteres na identação tornará você mais amigável na comunidade, se você planeja distribuir seu código).
17 | 18 | Na janela esquerda do SciTE digite: puts 'Olá' e então clique em _File/Save As..._ Dê o nome p001ola.rb e armazene ele no seu diretório programasruby. Pressione F5 para executar o programa. Você deveria ver Olá na janela de saída à direita. O programa é como o exibido abaixo: 19 | 20 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 21 | # p001ola.rb 22 | puts 'Olá' 23 | <% end -%> 24 | 25 | *Nota:* Ruby é uma linguagem de script. Não existe nenhum método principal especial por onde a execução do programa inicia. É dado ao interpretador do Ruby um script de instruções para executar, e ele começa da primeira linha e continua até a última linha. *puts* (a letra *s* em *puts* quer dizer string; *puts* significa coloque uma string) simplesmente escreve na tela seja lá o que vier depois dele, mas ele também vai automaticamente para a próxima linha (exceto quando a string passada já termina com uma nova linha). 26 | 27 |
28 | a. Parênteses são geralmente opcionais nas chamadas de métodos. Todas as chamadas abaixo são válidas: 29 | foobar 30 | foobar() 31 | foobar(a, b, c) 32 | foobar a, b, c 33 | 34 | b. Em Ruby, tudo desde um inteiro até uma string é considerado um objeto (mais sobre isso depois). E cada objeto foi criado com 'métodos' (termo Ruby para funções) os quais podem ser usados para várias coisas úteis. Para usar um método, você precisa por um ponto depois do objeto, e então acrescentar o nome do método. Alguns métodos como o *puts* e o *gets* estão disponíveis em todos os lugares e não precisam ser associados a um objeto específico. 35 | Tecnicamente falando, esses métodos são fornecidos pelo módulo *Kernel* do Ruby (mais sobre isso depois) e eles são incluídos em todos os objetos Ruby (o módulo *Kernel* é incluído pela classe (mais sobre isso depois) *Object*, então esses métodos estão disponíveis em todo objeto Ruby). Quando você executa uma aplicação Ruby, um objeto chamado *main* da classe *Object* é automaticamente criado. Esse objeto proporciona acesso aos métodos de *Kernel*. 36 |
37 | 38 | h2. Observe 39 | 40 | # Programadores Java e C - não é necessário escrever um método/função main. 41 | # Literais string são sequências de caracteres entre aspas simples ou dupla. Eu estou usando aspas simples em volta de Olá. ' é mais eficiente que " (mais sobre isso depois). 42 | # Ruby é uma linguagem interpretada, então você não precisa recompilar para executar um programa escrito em Ruby. 43 | # Lançamentos do Ruby mesmo com números de sub-versões - 1.6, 1.8, e outros - são estáveis, versões públicas. Entretanto, em 2007 Matz quebrou a convenção e criou a versão 1.9 como uma versão pública e estável do Ruby. 44 | # A convenção de codificação Ruby diz que nomes de arquivos/diretórios são escritos em letra minúscula e com extensão .rb. Por exemplo, a classe Foo tem o nome foo.rb. 45 | <%- page_title, page_url = next_page %> 46 | 47 | -------------------------------------------------------------------------------- /_webby/content/procs.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Procs em Ruby 3 | created_at: 2010-04-24 17:40:01.610313 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | _Blocos não são objetos_, mas eles podem ser convertidos em objetos da classe *Proc*. Podemos fazer isso chamando o método *lambda*, presente no módulo *Kernel* do Ruby. Um bloco criado com *lambda* atua como um método Ruby. Caso você não especifique o número correto de argumentos, você não pode chamar o bloco. 11 | 12 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 13 | prc = lambda {"hello"} 14 | <% end %> 15 | 16 | Objetos *Proc* são blocos de código que são vinculados a um grupo de variáveis locais. A classe *Proc* tem uma chamada de método que invoca o bloco. O programa *p024proccall.rb* ilustra isso. 17 | 18 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 19 | # Blocos não são objetos 20 | # eles podem ser convertidos em objetos da classe Proc, 21 | # chamando o método lambda 22 | prc = lambda {puts 'Olá'} 23 | # o método call chama o bloco 24 | prc.call 25 | 26 | # outro exemplo 27 | brinde = lambda do 28 | puts 'Viva' 29 | end 30 | brinde.call 31 | <% end %> 32 | 33 | A saída deste código é: 34 | 35 | <% coderay(:lang => "text", :line_numbers => "inline") do -%> 36 | >ruby p024proccall.rb 37 | Olá 38 | Viva 39 | >Exit code: 0 40 | <% end %> 41 | 42 | Se você chamar o método _class_ do objeto prc, você verá que ele pertence a classe *Proc*, como podemos ver no exemplo abaixo: 43 | 44 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 45 | prc = lambda {puts 'Hello'} 46 | puts prc.class 47 | #a saída será Proc 48 | <% end %> 49 | 50 | Lembre-se que você não pode passar métodos dentro de outros métodos (mas você pode passar procs dentro dos métodos), e métodos não podem retornar outros métodos (mas eles podem retornar procs). 51 | 52 | O próximo exemplo mostra como _os métodos podem usar procs_. Exemplo *p025mtdproc.rb* 53 | 54 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 55 | =begin 56 | Você não pode passar métodos dentro de outros métodos 57 | (mas pode passar procs dentro dos métodos), 58 | e métodos não podem retornar outros métodos (mas eles podem retornar procs) 59 | =end 60 | 61 | def algum_metodo algum_proc 62 | puts 'Início do método' 63 | algum_proc.call 64 | puts 'Fim do método' 65 | end 66 | 67 | fale = lambda do 68 | puts 'Olá' 69 | end 70 | 71 | algum_metodo fale 72 | <% end %> 73 | 74 | A saída do exemplo será: 75 | 76 | <% coderay(:lang => "text", :line_numbers => "inline") do -%> 77 | >ruby p025mtdproc.rb 78 | Início do método 79 | Olá 80 | Fim do método 81 | >Exit code: 0 82 | <% end %> 83 | 84 | Aqui está outro exemplo da passagem de argumentos usando *lambda*. 85 | 86 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 87 | umBloco = lambda { |x| puts x } 88 | umBloco.call 'Olá Mundo!' 89 | # a saída será: Olá Mundo! 90 | <% end %> 91 | 92 |
93 | *Fabio Akita*, grande entusiasta do Rails e Ruby, também conhecido online como "AkitaOnRails", escreveu um excelente artigo sobre "Closures/Blocos em Ruby (em inglês)":http://rubylearning.com/blog/2007/11/30/akitaonrails-on-anatomy-of-ruby-blocksclosures/ para os membros do _rubylearning.com_, que também foi publicado em português no seu "blog":http://akitaonrails.com/2007/11/30/anatomia-de-ruby-blocks-closures. Se você quiser saber mais sobre blocos em Ruby, esse artigo poderá te ajudar em muito. 94 | 95 | Outro artigo recomendado é o do "Daniel Lopes":http://blog.areacriacoes.com.br/2008/9/22/blocos, que explica de uma forma bem didática o conceito e uso de blocos. 96 | 97 |
98 | 99 | <%- page_title, page_url = next_page %> 100 | 101 | -------------------------------------------------------------------------------- /_webby/content/recebendo-entrada.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Recebendo entrada 3 | created_at: 2009-06-28 14:05:42.935486 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Páginas atrás vimos o método *puts* que imprime texto na tela. Agora, como aceitar uma entrada do usuário? Para isso *gets* (pegar a string) e *chomp* (mastigar) são úteis. O exemplo *p005metodos.rb* abaixo ilustra o mesmo. 11 | 12 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 13 | # p005metodos.rb 14 | # gets e chomp 15 | puts "Em qual cidade você está?" 16 | STDOUT.flush 17 | cidade = gets.chomp 18 | puts "A cidade é " + cidade 19 | <% end -%> 20 | 21 | Quando você executar o exemplo acima no _SciTE_, clique no caixa de saída (no lado direito do _SciTE_) e então digite o nome de sua cidade. 22 | 23 | *STDOUT* é uma constante global que é a saída padrão atual do programa. *flush* (fluir) limpa qualquer dado armazenado no buffer (área de armazenamento temporário de dados) de entrada e saída do Ruby. O uso não é mandatório, mas recomendado. 24 | 25 | *gets* recebe uma linha única de dados da entrada padrão - o teclado nesse caso - e atribui a string digitada pelo usuário à variável *cidade*. 26 | 27 | *chomp* é um método de string e retorna apenas as strings do que veio do teclado. Você deve ter percebido que *gets* retorna uma string e o caractere '\n' (quebra de linha), enquanto *chomp* remove o '\n'. 28 | 29 |
*NO RAILS*: Os dados vêm de muitas fontes. Em uma aplicação típica do Rails, eles vêm do banco de dados. Como um desenvolvedor Rails, você pode se encontrar utilizando relativamente poucas dessas facilidades, porque o Rails faz o tratamento dos dados para você; e seus usuários, quando eles enviam entradas pelo teclado, estarão geralmente digitando em um formulário web.
30 | <%- page_title, page_url = next_page %> 31 | 32 | -------------------------------------------------------------------------------- /_webby/content/ruby-method-missing.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Ruby method missing (método faltando) 3 | created_at: 2009-11-17 14:16:47.913867 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Quando você envia uma mensagem a um objeto, este executa o primeiro método que ele encontra no "caminho de busca do método":http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf (arquivo PDF) com o mesmo nome da mensagem. Se ele falha em encontrar tal método, ele lança uma exceção do tipo *NoMethodError* - a menos que você tenha fornecido ao objeto um método chamado *method_missing* (método ausente). Ao método *method_missing* é passado o símbolo do método não existente, uma lista de argumentos que foram passados na chamada original e qualquer bloco passado ao método original. 11 | 12 | *method_missing* faz parte de uma rede de segurança: Ele lhe fornece um jeito de interceptar mensagens não respondidas e trata-as de maneira elegante. Veja o exemplo *p012zmm.rb* abaixo: 13 | 14 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 15 | class Dummy 16 | def method_missing(m, *args, &block) 17 | puts "Não há nenhum método chamado #{m} aqui." 18 | end 19 | end 20 | Dummy.new.qualquer_coisa 21 | <% end %> 22 | 23 | A saída é: 24 | 25 | <% coderay(:lang => "text", :line_numbers => "inline") do -%> 26 | >ruby p012zmm.rb 27 | Não há nenhum método chamado qualquer_coisa aqui. 28 | >Exit code: 0 29 | <% end %> 30 | 31 | Você também é responsável por manter a assinatura do *method_missing*. É possível escrever um gancho que captura apenas o nome de um método ausente enquanto ignora seus argumentos e o bloco associado. 32 | <%- page_title, page_url = next_page %> 33 | 34 | -------------------------------------------------------------------------------- /_webby/content/ruby-ri.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: A ferramente ri do Ruby 3 | created_at: 2009-10-20 23:19:30.459402 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | h2. ri e RDoc 11 | 12 | Se você tem uma boa conexão com a internet, então você provavelmente deveria consultar a documentação do Ruby online. Entretanto, 13 | para aqueles que possuem uma conexão mais lenta ou não tem acesso a uma conexão com a internet, as ferramentas Ruby ri e RDoc são 14 | bastante úteis. 15 | 16 | ri (o Índice Ruby) e RDoc (Documentação Ruby) são um par de ferramentas bastante relacionadas para prover documentação a respeito de programas em Ruby. O ri é uma ferramenta de linha de comando; o RDoc inclui uma ferramenta de linha de comando chamada rdoc. ri e rdoc são programas independentes; você executa ambos pela linha de comando. 17 | 18 | O RDoc é um sistema de documentação criado por "Dave Thomas":http://en.wikipedia.org/wiki/Dave_Thomas_(programmer). Se você colocar comentários nos arquivos de seu programa (Ruby ou C) no formato especificado pelo RDoc, o rdoc escaneia seus arquivos, extrai os comentários, os organiza de forma inteligente (indexados de acordo com aquilo que eles comentam) e cria uma documentação formatada a partir deles. Você pode ver a marcação do RDoc em muitos dos arquivos na árvore de código fonte do Ruby e em muitos arquivos Ruby na pasta de instalação do Ruby. Com o RDoc também é possível gerar uma versão em HTML da documentação como a da "documentação oficial":http://www.ruby-doc.org/ruby-1.9/. Existem diversos templates em HTML para o RDoc. Exemplos são o "Alisson":http://blog.evanweaver.com/files/doc/fauna/allison/files/README.html e o "Hanna:http://wiki.github.com/mislav/hanna". 19 | 20 | A ferramenta Ruby ri é usada para ver a documentação do ruby off-line. Abra uma janela de comando e execute o ri seguido pelo nome de uma classe, método ou módulo Ruby. O ri mostrará a documentação para você. Você pode especificar o nome de um método sem especificar uma classe ou módulo, mas isso lhe mostrará uma lista com todos os métodos como esse nome (ao menos que o método seja único). Normalmente, você pode separar uma classe ou módulo de um nome de método com um ponto (.). Se a classe define um método de classe e um método de instância com o mesmo nome você precisa usar :: para se referir ao método de classe ou # para se referir ao método de instância. Aqui estão alguns exemplos de chamada do ri: 21 | 22 | 23 | <% coderay(:lang => "bash", :line_numbers => "inline") do -%> 24 | ri Array 25 | ri Array.sort 26 | ri Hash#each 27 | ri Math::sqrt 28 | <% end -%> 29 | 30 | O ri se encaixa ao RDoc: Ele lhe oferece um jeito de visualizar a informação que o RDoc extraiu e organizou. Especificamente (embora não exclusivamente, se você customizá-lo), o ri é configurado para mostrar a informação do Rdoc dos arquivos fontes do Ruby. Então em qualquer sistema que você tenha o Ruby instalado por completo, você pode obter informação detalhada sobre o Ruby apenas com uma chamada de linha de comando do ri. Você encontra informações adicionais nos seguintes sites (em inglês): 31 | 32 | "http://www.caliban.org/ruby/rubyguide.shtml#ri":http://www.caliban.org/ruby/rubyguide.shtml#ri 33 | "http://en.wikipedia.org/wiki/RDoc":http://en.wikipedia.org/wiki/RDoc 34 | "http://www.ruby-doc.org/core/classes/RDoc.html":http://www.ruby-doc.org/core/classes/RDoc.html 35 | "http://www.rubyinside.com.br/rdoc-algumas-maneiras-alternativas-de-consultar-documentacao-1469"http://www.rubyinside.com.br/rdoc-algumas-maneiras-alternativas-de-consultar-documentacao-1469 36 | 37 | 38 | <%- page_title, page_url = next_page %> 39 | 40 | 41 | -------------------------------------------------------------------------------- /_webby/content/self.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Self 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Em cada ponto em que seu programa está rodando, há um único self - o objeto atual ou padrão acessível para você em seu programa. Você pode dizer qual objeto self representa seguindo um pequeno conjunto de regras. 11 | 12 | h2. Contexto de nível superior 13 | 14 | O contexto de nível superior é aquele que ocorre antes de você entrar em qualquer outro contexto, como uma definição de classe. Então o termo nível superior se refere ao código escrito externamente a uma classe ou módulo. Se você abrir um novo arquivo de texto e digitar: 15 | 16 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 17 | x = 1 18 | <% end -%> 19 | 20 | Você criou uma variável local de nível superior. Se você digitar: 21 | 22 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 23 | def m 24 | end 25 | <% end -%> 26 | 27 | Você terá criado um método de nível superior - um método de instância de Object (embora self não seja um Object). Métodos de nível superior são sempre privados. O Ruby lhe provê um self inicial no nível mais alto. Se digitar: 28 | 29 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 30 | puts self 31 | <% end -%> 32 | 33 | Ele mostrará main (principal) - um termo especial que o objeto self usa para referir-se a si mesmo. A classe do objeto main é Object. 34 | 35 | h2. Self dentro de definições de classes e módulos 36 | 37 | Em uma definição de classe ou módulo, self é o objeto da classe ou do módulo. 38 | 39 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 40 | # p063xself1.rb 41 | class S 42 | puts 'Acabei de começar a classe S' 43 | puts self 44 | module M 45 | puts 'Módulo aninhado S::M' 46 | puts self 47 | end 48 | puts 'De volta ao nível externo de S' 49 | puts self 50 | end 51 | <% end -%> 52 | 53 | 54 | A saída é: 55 | 56 | <% coderay(:lang => "bash", :line_numbers => "inline") do -%> 57 | >ruby p063xself1.rb 58 | Acabei de começar a classe S 59 | S 60 | Módulo aninhado S::M 61 | S::M 62 | De volta ao nível externo de S 63 | S 64 | >Exit code: 0 65 | <% end -%> 66 | 67 | 68 | h2. Self na definição de métodos de instância 69 | 70 | Quando a definição de um método é executada, o máximo que você pode dizer é que self dentro deste método será algum objeto futuro que tem acesso ao mesmo. 71 | 72 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 73 | # p063xself2.rb 74 | class S 75 | def m 76 | puts 'Classe S método m:' 77 | puts self 78 | end 79 | end 80 | s = S.new 81 | s.m 82 | <% end -%> 83 | 84 | 85 | A saída será: 86 | 87 | <% coderay(:lang => "bash", :line_numbers => "inline") do -%> 88 | >ruby p063xself2.rb 89 | Classe S método m: 90 | # 91 | >Exit code: 0 92 | <% end -%> 93 | 94 | 95 | A saída # é o jeito do Ruby de dizer "uma instância de S". 96 | 97 | 98 | h2. Self em um método singleton e em definições de métodos de classe 99 | 100 | Métodos singleton - aqueles que estão associados a um objeto e que podem ser chamados apenas por esse objeto. Quando um método singleton é executado, self é o objeto que é o dono do método, como mostrado abaixo: 101 | 102 | 103 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 104 | # p063xself3.rb 105 | obj = Object.new 106 | def obj.show 107 | print 'Sou um objeto: ' 108 | puts "aqui self está dentro de um método singleton que me pertence:" 109 | puts self 110 | end 111 | obj.show 112 | print 'E inspecionando o objeto por fora, ' 113 | puts "para ter certeza que é o mesmo objeto:" 114 | puts obj 115 | <% end -%> 116 | 117 | 118 | A saída do exemplo acima é: 119 | 120 | <% coderay(:lang => "bash", :line_numbers => "inline") do -%> 121 | >ruby p063xself3.rb 122 | Sou um objeto: aqui self está dentro de um método singleton que me pertence: 123 | # 124 | E inspecionando o objeto por fora, para ter certeza que é o mesmo objeto: 125 | # 126 | >Exit code: 0 127 | <% end -%> 128 | 129 | 130 | Métodos de classe são definidos como métodos singleton para objetos do tipo classe. Veja o seguinte programa: 131 | 132 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 133 | # p063xself4.rb 134 | class S 135 | def S.x 136 | puts "Método de classe da classe S" 137 | puts self 138 | end 139 | end 140 | S.x 141 | <% end -%> 142 | 143 | A saída é: 144 | 145 | <% coderay(:lang => "bash", :line_numbers => "inline") do -%> 146 | >ruby p063xself4.rb 147 | Método de classe da classe S 148 | S 149 | >Exit code: 0 150 | <% end -%> 151 | 152 | self dentro de um método singleton (um método de classe, nesse caso) é o objeto que possui o método singleton. 153 | <%- page_title, page_url = next_page %> 154 | 155 | 156 | -------------------------------------------------------------------------------- /_webby/content/serializacao-de-objetos.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Serialização de objetos 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | A linguagem Java possui a habilidade de serializar objetos, permitindo que você os armazene em algum lugar e depois os reconstitua quando necessário. O Ruby chama esse tipo de serialização de marshaling (empacotamento). 11 | 12 | Escreveremos uma classe básica (**p051gamecharacters.rb**) apenas para testar o marshaling. 13 | 14 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 15 | # p051gamecharacters.rb 16 | class PersonagemDoJogo 17 | def initialize(poder, tipo, armas) 18 | @poder = poder 19 | @tipo = tipo 20 | @armas = armas 21 | end 22 | attr_reader :poder, :tipo, :armas 23 | end 24 | <% end -%> 25 | 26 | O programa **p052dumpgc.rb** cria um objeto da classe acima e então usa **Marshal.dump** para salvar a versão serializada dele no disco. 27 | 28 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 29 | # p052dumpgc.rb 30 | require 'p051gamecharacters' 31 | gc = PersonagemDoJogo.new(120, 'Mago', [magias, 'invisibilidade']) 32 | puts gc.poder.to_s + ' ' + gc.tipo + ' ' 33 | gc.armas.each do |w| 34 | puts w + ' ' 35 | end 36 | 37 | File.open('jogo', 'w+') do |f| 38 | Marshal.dump(gc, f) 39 | end 40 | <% end -%> 41 | 42 | O programa **p053loadgc.rb** usa **Marshal.load** para lê-lo. 43 | 44 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 45 | # p053loadgc.rb 46 | require 'p051gamecharacters' 47 | File.open('joho') do |f| 48 | @gc = Marshal.load(f) 49 | end 50 | 51 | puts @gc.poder.to_s + ' ' + @gc.tipo + ' ' 52 | @gc.armas.each do |w| 53 | puts w + ' ' 54 | end 55 | <% end -%> 56 | 57 | **Marshal** apenas serializa estruturas de dados. Ele não pode serializar código Ruby (como objetos do tipo Proc), ou recursos alocados por outros processos (como tratadores de arquivo ou conexões com bancos de dados). **Marshal** apenas lhe dará um erro quando tentar serializar um arquivo. 58 | <%- page_title, page_url = next_page %> 59 | 60 | 61 | -------------------------------------------------------------------------------- /_webby/content/series.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: Séries (Ranges) 3 | created_at: 2010-03-10 11:52:48.875419 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | O primeiro e talvez o mais natural uso das séries (intervalos ou, em inglês, ranges) é para expressar uma sequência. Sequências tem um ponto de início, um ponto de término e um modo de produzir valores sucessivos na sequência. No Ruby, essas sequências são criadas usando os operadores de intervalo ".." e "...". A forma com dois pontos cria uma série inclusiva e a forma de três pontos cria uma série que exclui o valor mais alto especificado. No Ruby as séries não são interpretadas internamente como listas: a sequência 1..100000 é armazenada como um objeto do tipo **Range** contendo referências a dois objetos **Fixnum**. Remeta-se ao programa **p021ranges.rb**. Caso você precise, é possível converter uma série para uma lista (array) usando o método **to_a**. 11 | 12 | 13 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 14 | (1..10).to_a -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 15 | <% end %> 16 | 17 | Séries implementam métodos que permitem que você itere sobre elas e teste seus conteúdos de diversas maneiras. 18 | 19 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 20 | # p021ranges.rb 21 | =begin 22 | Sequências tem um ponto de início, de término 23 | e um modo de produzir valores sucessivos 24 | No Ruby, essas sequências são criadas usando os 25 | operadores de intervalo ".." e "...". 26 | A forma com dois pontos cria uma série 27 | inclusiva e a forma de três pontos cria uma 28 | série que exclui o valor mais alto especificado. 29 | =end 30 | digitos = -1..9 31 | puts digitos.include?(5) # true 32 | puts digitos.min # -1 33 | puts digitos.max # 9 34 | puts digitos.reject {|i| i < 5 } # [5, 6, 7, 8, 9] 35 | <% end %> 36 | 37 | Outro uso do versátil Range é para testar um intervalo: verificar se algum valor está dentro do intervalo representado pela série. Fazemos isso usando o operador de igualdade ===. 38 | 39 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 40 | (1..10) === 5 -> true 41 | (1..10) === 15 -> false 42 | (1..10) === 3.14159 -> true 43 | ('a'..'j') === 'c' -> true 44 | ('a'..'j') === 'z' -> false 45 | <% end %> 46 | <%- page_title, page_url = next_page %> 47 | 48 | -------------------------------------------------------------------------------- /_webby/content/sobrecarregando-metodos.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Sobrecarregando métodos em Ruby" 3 | created_at: 2010-05-06 21:10:49.600687 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | **Você quer criar duas versões diferentes de um método possuindo o mesmo nome: dois métodos que diferem entre si pelos argumentos que possuem.** Porém, uma _classe Ruby pode ter somente um método com um determinado nome_ (se você definir um método com o mesmo nome duas vezes, a definição do último método prevalece conforme visto no exemplo **p038or.rb** no tópico **Sobrescrevendo métodos em Ruby**). Dentro daquele método simples, então, você pode por a lógica que varia dependendo de quantos e que tipos de objetos foram passados a ele como argumentos. 11 | 12 | Aqui está uma classe _Retangulo_ que representa uma forma retangular num plano. Você pode instanciar um _Retangulo_ de um dos dois jeitos: passando as coordenadas de seus cantos superior esquerdo e inferior direito, ou passando as coordenadas de seu canto superior esquerdo junto com seu tamanho e largura. Há apenas um método **initialize**, mas você pode chamá-lo como se houvessem dois. 13 | 14 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 15 | # O construtor do Retangulo aceita argumento em ambas 16 | # das seguintes formas: 17 | # Retangulo.new([x_superior, y_esquerda], tamanho, largura) 18 | # Retangulo.new([x_superior, y_esquerda], [x_inferior, y_direita]) 19 | class Retangulo 20 | def initialize(*args) 21 | if args.size < 2 || args.size > 3 22 | # modificar isto para lançar exceção, depois 23 | puts 'Este metodo recebe 2 ou 3 argumentos' 24 | else 25 | if args.size == 2 26 | puts 'Dois argumentos' 27 | else 28 | puts 'Tres argumentos' 29 | end 30 | end 31 | end 32 | end 33 | 34 | Retangulo.new([10, 23], 4, 10) 35 | Retangulo.new([10, 23], [14, 13]) 36 | <% end -%> 37 | 38 | O programa **p037retangulo.rb**, acima, está incompleto da perspectiva da classe _Retangulo_, mas é suficiente para demonstrar como é feita a sobrecarga de métodos. Lembre-se, também, que o método **initialize** recebe um número variável de argumentos. 39 | 40 | h2. Sumário 41 | 42 | Eu listei todos os "pontos importantes":sumario-ruby5.html que você precisa lembrar depois de concluir os seguintes tópicos: **Incluindo outros arquivos**, **Classes abertas em Ruby**, **Herança**, **Sobrescrevendo métodos**, **Sobrecarregando métodos**. 43 | 44 | <%- page_title, page_url = next_page %> 45 | 46 | 47 | -------------------------------------------------------------------------------- /_webby/content/sobreposicao-de-metodos.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Sobreposição (Overriding) de Métodos" 3 | created_at: 2010-05-11 09:23:39.261413 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | **Sobreposição de métodos** (override) em programação orientada a objetos, é um recurso da linguagem que permite que a subclasse, rescreva uma implementação especifica de um método que já esta previsto em uma superclasse. A implementação na subclasse sobrepõe a implementação na superclasse. 11 | 12 | Aqui esta um exemplo **p037xmtdoverride.rb**: 13 | 14 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 15 | class A 16 | def a 17 | puts 'Na classe A' 18 | end 19 | end 20 | 21 | class B < A 22 | def a 23 | puts 'Na classe B' 24 | end 25 | end 26 | 27 | b = B.new 28 | b.a 29 | <% end -%> 30 | 31 | O Método na classe B sobrepôs o método na classe A. 32 | 33 | h2. Uso do super 34 | 35 | A forma de se lidar com argumentos **super**: 36 | 37 | * Quando você invoca **super** sem argumentos, Ruby envia uma mensagem para o pai do objeto atual, pedindo para invocar um método do mesmo nome que o método que invocou **super**, ele automaticamente encaminha os argumentos que foram passados para o método a partir de qual foi chamado. 38 | * Chamando com uma lista de argumentos vazia - **super()**- ele não envia argumentos para o primeiro método, até mesmo se os argumentos foram passados para o método atual. 39 | * Chamando com argumentos específicos - **super(a, b, c)** - envia exatamente esses argumentos. 40 | 41 | 42 | Um exemplo (**p038bicycle.rb**) do livro _Ruby for Rails_ enfatiza isso: 43 | 44 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 45 | class Bicicleta 46 | attr_reader :marchas, :rodas, :bancos 47 | def initialize(gears = 1) 48 | @rodas = 2 49 | @bancos = 1 50 | @marchas = gears 51 | end 52 | end 53 | 54 | class Tandem < Bicicleta 55 | def initialize(gears) 56 | super 57 | @bancos = 2 58 | end 59 | end 60 | 61 | t = Tandem.new(2) 62 | puts t.marchas 63 | puts t.rodas 64 | puts t.bancos 65 | b = Bicicleta.new 66 | puts b.marchas 67 | puts b.rodas 68 | puts b.bancos 69 | <% end -%> 70 | 71 | 72 | A saída: 73 | 74 | <% coderay(:lang => "text", :line_numbers => "inline") do -%> 75 | >ruby p038bicycle.rb 76 | 2 77 | 2 78 | 2 79 | 1 80 | 2 81 | 1 82 | >Exit code: 0 83 | <% end -%> 84 | 85 | 86 | Vamos falar com mais detalhes sobre **attr_reader** "mais tarde":controle-de-acesso.html. 87 | 88 | 89 | h2. Redefinindo Métodos 90 | 91 | (Adaptado do livro de David Black, Ruby for Rails) 92 | 93 | Nada impede que você defina um método duas vezes. Programa **p038or.rb**: 94 | 95 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 96 | class OR 97 | def mtd 98 | puts "Primeira definição do método mtd" 99 | end 100 | def mtd 101 | puts "Primeira definição do método mtd" 102 | end 103 | end 104 | OR.new.mtd 105 | <% end -%> 106 | 107 | 108 | O que acontece quando chamamos o mtd em uma instancia de OR? Vamos descobrir: 109 | 110 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 111 | OR.new.mtd 112 | <% end -%> 113 | 114 | 115 | O resultado mostrado é a segunda definição do método mtd. A segunda definição é prevalecida: Nós vemos o resultado pela segunda, não pela primeira. Nada impede que você defina um método duas vezes, no entanto, a nova versão tem precedência. 116 | 117 | 118 | h2. Classe Abstrata 119 | 120 | Em Ruby, podemos definir uma classe abstrata como a que invoca certos métodos “abstratos” indefinidos, que é deixado para as subclasses definir. Por exemplo: 121 | 122 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 123 | # Essa classe é abstrata, mais não define Ola ou Nome   124 | # Nenhuma sintaxe especial é necessária: qualquer classe que invoca métodos 125 | # que são destinados para uma subclasse é abstrata 126 | 127 | class AbstractKlass 128 | def bemvindo 129 | puts "#{ola} #{nome}" 130 | end 131 | end 132 | 133 | # uma classe concreta 134 | class ConcreteKlass < AbstractKlass 135 | def ola; "Ola"; end 136 | def nome; "Estudantes de Ruby"; end 137 | end 138 | 139 | ConcreteKlass.new.bemvindo # imprime "Ola Estudantes de Ruby" 140 | <% end -%> 141 | <%- page_title, page_url = next_page %> 142 | 143 | 144 | -------------------------------------------------------------------------------- /_webby/content/sumario-ruby3.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Resumo 3" 3 | created_at: 2009-11-19 15:07:29.489200 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | # Refira-se a "documentação da classe String":http://ruby-doc.org/core/classes/String.html para usar os vários métodos disponíveis. 11 | # Para strings literais com aspas duplas, o Ruby procura por substituições - sequências que começam com uma barra invertida - e as substitui com algum valor binário ou faz a interpolação da expressão, por exemplo, dentro da string, a sequência *#{expressao}* é substituída pelo valor da expressão. 12 | # É importante notar que cada vez que uma literal string é usada em uma atribuição ou como parâmetro, um novo objeto String é criado. 13 | # Observe como se pode listar todos os métodos de uma classe ou objeto. 14 | # Comparar duas strings para igualdade pode ser feito com *==* ou *.eql?* (para conteúdo idêntico) e *.equal?* (para objetos iguais). 15 | # *%w* é comumente usada com strings. 16 | # Observe o uso dos construtores: *if else end*, *while*, *if elsif end*. 17 | # O Ruby também tem uma versão negada do construtor if, o *unless end*. 18 | # Expressões *case*: Esta forma é bastante próxima a uma série de instruções *if*: ela permite que você liste uma série de condições e executa uma instrução correspondente a primeira condição que foi verdadeira. *case* retorna o valor da última expressão executada. Uso: *case when else end*. 19 | # *IMPORTANTE*: Os blocos de código Ruby são pedaços de código entre chaves ou entre *do end* que você pode associar com chamadas a métodos. 20 | # Blocos de código podem aparecer apenas no código adjacente a uma chamada de método; o bloco é escrito começando na mesma linha do último parâmetro da chamada do método (ou o parênteses de fechamento da lista de parâmetros). O código no bloco não é executado quando é encontrado. Ao invés disso, o Ruby se lembra do contexto no qual o bloco aparece (as variáveis locais, o objeto atual e assim por diante) e então entra no método. 21 | # O padrão do Ruby é usar chaves para blocos de uma única linha e *do end* para blocos de múltiplas linhas. Lembre-se que a sintaxe com chaves tem precedência maior que a sintaxe *do end*. 22 | # Dentro de um método, você pode chamar um bloco de código Ruby usando a palavra *yield* com um valor. 23 | # Você pode fornecer parâmetros para a chamada ao *yield*: estes serão passados ao bloco. Dentro do bloco, você lista os argumentos para receber os parâmetros entre barras verticais (|). 24 | 25 | <%- page_title, page_url = next_page %> 26 | 27 | 28 | -------------------------------------------------------------------------------- /_webby/content/sumario-ruby4.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Resumo 4" 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | 11 | 12 | # Um Array é uma lista de itens em ordem. Cada lacuna na lista atua como uma variável: você pode ver a qual objeto uma lacuna aponta, e você pode fazer ela apontar para um objeto diferente. Você pode criar um array usando colchetes [] 13 | # Arrays são indexados por números inteiros e o índice inicia em 0. 14 | # Você pode acessar um Array além dos seus limites; ele retornará nil. 15 | # Uma vírgula sobrando na declaração de um array é ignorada (Ex: [1, 2, 3,]) 16 | # Refira-se a "documentação da classe Array":http://ruby-doc.org/core/classes/Array.html para uma lista de métodos. 17 | # Podemos adicionar novos elementos a um Array existente. 18 | # O método each (para cada objeto) é um iterador que extrai cada elemento do array. O método each permite que façamos o que quisermos com cada um dos objetos que o array aponta. 19 | # A variável entre as barras verticais, isto é, | | refere-se a cada item no array a medida que ele é iterado no loop. Você pode dar a essa variável o nome que desejar. 20 | # Sequências tem um ponto de início, de término e um modo de produzir valores sucessivos na sequência. No Ruby, essas sequências são criadas usando os operadores de intervalo *".."* e *"..."*. 21 | # A forma com os dois pontos cria um intervalo inclusivo, e a forma com três pontos cria um intervalo exclusivo, excluindo o valor mais alto do intervalo. 22 | # No Ruby, a sequência *1..100000* é armazenada como um objeto do tipo *Range* contendo referências a dois objetos *Fixnum*. 23 | # O método *.to_a* converte um Range em um *Array*. 24 | # Outro uso versátil do range é no teste de um intervalo: ver se um valor está dentro do intervalo representado pelo range. Fazemos isso usando *===*, o operador de igualdade de caso. 25 | # Ranges não estão limitados a inteiros ou números. O início e o fim de um intervalo pode ser qualquer objeto Ruby. 26 | # Um símbolo (symbol) parece com um nome de variável mas é prefixado com dois pontos. 27 | # Você pode pensar em *:id* como significando o nome da variável id, e *id* (sem os dois pontos) como o valor da variável. 28 | # Símbolos são úteis porque um nome de símbolo se refere ao mesmo objeto ao longo de um programa Ruby. 29 | # Símbolos podem ser considerados constantes sem valores. 30 | # Símbolos são mais eficientes que strings. Duas strings com o mesmo conteúdo são dois objetos diferentes, mas para qualquer nome, existe apenas um objeto *Symbol*. Isso pode economizar tanto tempo quanto memória. 31 | # Quando usamos uma string ou um símbolo? 32 | ## Se o conteúdo (a sequência de caracteres) do objeto é importante, use uma string. 33 | ## Se a identidade do objeto é importante, use um símbolo. 34 | # Um objeto do tipo símbolo é criado prefixando um operador, string, variável, constante, método, nome de módulo com dois pontos. 35 | # Se *Fred* é uma constante em um contexto, um método em outro e uma classe em um terceiro, o Símbolo *:Fred* será o mesmo objeto nos três contextos. 36 | # Hashes são similares a arrays por representarem uma coleção indexada de referências a objetos. Entretanto, enquanto você indexa os arrays com inteiros, você pode indexar um hash com objetos de qualquer tipo: strings, expressões regulares e assim por diante. 37 | # Quando você armazena um valor em um hash, você realmente provê dois objetos - o índice (normalmente chamado chave ou key) e o valor. 38 | # nil é retornado quando se tenta acessar uma chave que não existe no hash. 39 | # O método para obter um número escolhido aleatoriamente no Ruby é o rand. 40 | # Se você chamar rand você obterá um float maior ou igual a 0.0 e menor que 1.0. Se você der a ele um inteiro como parâmetro de entrada (chamando, por exemplo, *rand(5)*), você obterá um inteiro maior ou igual a 0 e menor que 5. 41 | # O método *File.open* pode abrir um arquivo em modos diferentes como *'r'* (somente leitura, iniciando no começo do arquivo (padrão)); *'r+'* (Escrita/leitura, inicia no começo do arquivo); *'w'* (somente escrita), troca o arquivo existente para o tamanho vazio ou cria um novo arquivo para escrita. 42 | # *File.open* abre um novo arquivo se não há nenhum bloco associado. Se o bloco é dado, ele passará o arquivo como um argumento, e o arquivo será automaticamente fechado quando o bloco terminar. 43 | # Sempre feche um arquivo que você abrir. No caso de um arquivo aberto para escrita, isso é muito importante e pode realmente prevenir uma perda de dados. 44 | # O método *seek* (procurar) da classe *IO*, busca por um dado offset de um Inteiro (primeiro parâmetro ou método) no stream de acordo com o valor do segundo parâmetro no método. O segundo parâmetro pode ser IO::SEEK_CUR - busca o número inteiro do primeiro parâmetro mais o valor da posição atual; IO:SEEK_END - busca o número inteiro do primeiro parâmetro mais o valor do final do stream (você provavelmente quer um valor negativo para o número inteiro do primeiro parâmetro); IO:SEEK_SET - Busca a posição absoluta dada pelo número inteiro do primeiro parâmetro. 45 | <%- page_title, page_url = next_page %> 46 | 47 | 48 | -------------------------------------------------------------------------------- /_webby/content/sumario-ruby6.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Resumo 6" 3 | created_at: 2010-07-07 20:50:25.387994 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | # Ruby oferece três níveis de proteção: 11 | ** *public* - os métodos podem ser chamados por todos. Por padrão, os métodos instanciados na classe são públicos. 12 | ** *protected* - os métodos podem ser chamados apenas pelos objetos da classe que os definem e suas subclasses. 13 | ** *private* - os métodos não podem ser chamados com um receptor explícito - o receptor é sempre o *self*. Isto significa que os métodos privados podem ser chamados somente no contexto do objeto atual (não podemos utilizar self.metodo). Uma observação a ser feita, é que o método initialize é sempre privado. 14 | # O controle de acesso é determinado dinamicamente, quando o programa roda, e não estaticamente. Você receberá uma violação de acesso apenas quando o código tentar executar o método restrito. 15 | # Os métodos de alto nível são métodos privados de instância do módulo *Kernel*. 16 | # _attr_reader_ é apenas leitor (getter), e o _attr_writer_ apenas escritor (setter), já o _attr_accessor_ é ambos, leitor e escritor. 17 | # Uma exceção é um tipo especial de objeto, uma instância da classe *Exception* ou uma descendente dessa classe. 18 | # O método *raise* é do módulo *Kernel*. Por padrão, o *raise* cria uma exceção da classe *RuntimeError*. Para levantar uma exceção de uma classe específica, você pode passar o nome da classe como um parâmetro para o *raise*. 19 | # Para fazer o controle de exceção, colocamos o código que pode gerar uma exceção em um bloco *begin-end* e usamos uma ou mais cláusulas de *rescue* para informar ao Ruby os tipos de exceções que queremos manipular. 20 | # É bom lembrar que o corpo de uma definição do método é um bloco *begin-end* implícito; o begin é omitido, e todo o corpo do método está sujeito ao controle de exceção, que termina com o end do método. 21 | # Se você escreve uma cláusula *rescue* sem passar parâmetros, os parâmetros serão ajustados para o padrão *StandardError*. 22 | # Se você precisar de alguma garantia de que algum processamento é feito no final de um bloco de código, independentemente se uma exceção foi levantada ou não, então a cláusula *ensure* pode ser usada. O *ensure* vai após a última cláusula *rescue* e contém um pedaço de código que será sempre executado quando o bloco termina. O bloco de *ensure* sempre será executado. 23 | # Por padrão, a mensagem inspect, que pode ser enviada para qualquer objeto, formata o ID do objeto e as variáveis da instância. Retornando uma string contendo uma representação legível do objeto. Se não for sobrescrito, usa o método to_s para gerar a string. 24 | # A classe Tempo contém a interface do Ruby para o conjunto de bibliotecas de tempo escritas em C. 25 | # Hora zero para o Ruby é o primeiro segundo GMT de 01 de janeiro de 1970. 26 | # A classe *DateTime* do Ruby é superior a *Time* para aplicações da área de Astronomia e História, mas você pode usar a *Time* para a maioria das aplicações diárias. 27 | 28 | <%- page_title, page_url = next_page %> 29 | 30 | 31 | -------------------------------------------------------------------------------- /_webby/content/sumario-ruby7.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Resumo 7" 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | # No Ruby, nós dependemos menos do tipo (ou classe) de um objeto e mais em suas capacidades. Deste modo, __Duck Typing__ significa que o tipo de um objeto é definido por aquilo que ele pode fazer, não por aquilo que ele é. 11 | # _Duck Typing_ se refere a tendência do Ruby de se preocupar menos com a classe de um objeto e mais com quais métodos podem ser chamados nela e quais operações ela suporta. 12 | # No Ruby, podemos usar **respond_to?** ou podemos simplesmente passar um objeto para um método e então saber que uma exceção será lançada se for usado inapropriadamente. 13 | # Açúcares sintáticos (__Syntatic Sugars__) se referem as regras que permitem a você escrever seu código de modo que ele não corresponda as regras normais mas que seja mais fácil de se lembrar de como fazer e que tenha melhor aparência. 14 | # Ruby permite que você defina métodos que terminem com um sinal de igual (=). 15 | # Objetos mutáveis são objetos cujo estado pode mudar. Objetos imutáveis são objetos cujo estado nunca se altera após sua criação. 16 | # Mutabilidade é a propriedade de uma instância, não de uma classe inteira. Qualquer instância pode se tornar imutável chamando-se o método **freeze** (congelar). 17 | # O método **freeze** na classe **Object** previne que você altere um objeto, efetivamente transformando-o em uma constante. Após congelarmos um objeto, uma tentativa de modificá-lo resultará em um __RuntimeError__. 18 | # **freeze** opera na referência de um objeto, não em uma variável. Isso significa que qualquer operações resultando em um novo objeto funcionará. 19 | # O método *frozen?* lhe diz se um objeto está ou não congelado (é ou não imutável). 20 | <%- page_title, page_url = next_page %> 21 | 22 | 23 | -------------------------------------------------------------------------------- /_webby/content/sumario-ruby8.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Resumo 8" 3 | created_at: 2009-12-23 14:29:25.387994 -02:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | # Módulos Ruby são similares a classes em relação ao fato de que também armazenam uma coleção de métodos, constantes e outras definições de módulos e classes. Entretanto, diferente das classes, você não pode criar objetos baseados em módulos; ao invés disso, você especifica qual funcionalidade de um módulo específico você deseja adicionar a uma classe ou a um objeto específico. 11 | # Módulos tem dois propósitos principais: Primeiro agem como namespace, permitindo que você defina métodos cujos nomes não irão coincidir com outros já definidos. Em segundo lugar, eles permitem que você compartilhe funcionalidade entre classes - se uma classe inclui um módulo, os métodos de instância do módulo ficam disponíveis como se tivessem sido definidos na classe. Eles são 'misturados' (mixed in) a classe. 12 | # Observe como você pode usar **require** ou **load** para arquivos e **include** para os múdulos. 13 | # Lembre-se que você pode incluir mais de um módulo em uma classe. Entretanto, uma classe não pode herdar de mais de uma classe. 14 | # Nomes de classe tendem a ser substantivos, enquanto nomes de módulos são com frequência adjetivos. 15 | # Em cada lugar que seu programa roda, existe um e apenas um **self** - o objeto atual ou objeto padrão que você tem acesso em seu programa. 16 | # Observe que as regras dadas para self na página relacionada a "Self":self.html. 17 | # O Java possui a habilidade de serializar objetos, permitindo que você os armazene e reconstitua-os quando necessário. O Ruby chama esse tipo de serialização de marshaling (empacotamento). 18 | # **Marshal.dump** é usado para salvar uma versão serializada de um objeto. 19 | # **Marshal.load** é usado para ler o objeto serializado de um arquivo. 20 | # Uma constante Ruby é uma referência para um objeto. 21 | # Embora constantes não devam ser alteradas, você pode modificar o estado interno de objetos referenciados pelas mesmas. 22 | # Lembre-se das regras para constantes. 23 | 24 | <%- page_title, page_url = next_page %> 25 | 26 | 27 | -------------------------------------------------------------------------------- /_webby/content/variaveis-e-atribuicao.txt: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Variáveis e atribuição" 3 | created_at: 2009-05-24 19:29:50.945539 -03:00 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%= h(@page.title) %> 9 | 10 | Para armazenar um número ou string na memória de seu computador para usar posteriormente em seu programa, você precisa dar um nome para esse número ou string. Programadores frequentemente referem-se a esse processo como atribuição e chamam os nomes de variáveis. Uma variável começa a existir assim que o interpretador vê uma atribuição para essa variável. 11 | 12 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 13 | s = 'Olá Mundo!' 14 | x = 10 15 | <% end -%> 16 | 17 |
18 | Uma bareword é qualquer combinação de letras, números e underscores, e não é qualificada por nenhum símbolo (Referência: "http://alumnus.caltech.edu/~svhwan/prodScript/avoidBarewords.html":http://alumnus.caltech.edu/~svhwan/prodScript/avoidBarewords.html). Variáveis locais e barewords parecem similares; elas devem iniciar com underscore (_) ou uma letra minúscula, e elas devem consistir inteiramente de letras, números e underscores. Lembre-se, referências a variáveis locais parecem com invocações de métodos e palavras chaves não podem ser usadas como nomes de variáveis (locais). 19 | 20 | Chamadas a métodos também podem ser barewords, como em meu_metodo. *gets* é uma chamada a um método; assim como *system*. Seja lá onde o Ruby vê uma bareword, ele interpreta-a como uma entre três coisas: (a) Se existe um sinal de igual do lado direito da bareword, ela é uma variável local sofrendo uma atribuição. (b) Ruby tem uma lista interna de palavras chaves e uma bareword pode ser uma delas. (c) Se uma bareword não é (a) ou (b), ela é assumida como sendo uma chamada a método. Se não existe nenhum método com esse nome, Ruby lança um *NameError*. 21 |
22 | 23 | O programa *p004usodestring.rb* mostra-nos mais algumas formas de uso de strings. 24 | 25 | <% coderay(:lang => "ruby", :line_numbers => "inline") do -%> 26 | # p004usodestring.rb 27 | # Definindo uma constante 28 | PI = 3.1416 29 | puts PI 30 | # Definindo uma variável local 31 | minha_string = 'Eu amo minha cidade' 32 | puts minha_string 33 | =begin 34 | Conversões 35 | .to_i, .to_f, .to_s 36 | =end 37 | var1 = 5; 38 | var2 = '2' 39 | puts var1 + var2.to_i 40 | # << juntando a uma string 41 | a = 'Olá ' 42 | a<<'mundo. 43 | Eu amo esse mundo...' 44 | puts a 45 | =begin 46 | << marca o início de seu literal string e 47 | é seguido por um delimitador de sua escolha. 48 | O literal string inicia então na próxima linha 49 | e termina quando o delimitador é repetido em 50 | uma linha onde ele aparece sozinho. 51 | Isso é conhecido como "Here document syntax". 52 | =end 53 | a = < 59 | 60 |
61 | No exemplo: 62 | x = "200.0".to_f 63 | o ponto significa que a mensagem "to_f" está sendo enviada para a string "200.0", ou que o método to_f está sendo chamado na string "200.0". A string "200.0" é chamada de receptor da mensagem. Assim, quando você vê um ponto nesse contexto, você deveria interpretá-lo como uma mensagem (à direita) sendo enviada para um objeto (à esquerda). 64 |
65 | 66 | h2. Sumário 67 | 68 | Eu listei todos os "pontos importantes":sumario-ruby1.html que você precisa lembrar depois de ter completado os seguintes tópicos: "Introdução":introducao.html, "Instalação":instalacao.html, "Primeiro programa Ruby":primeiro-programa-ruby.html, "Características":caracteristicas.html, "Números em Ruby":numeros-em-ruby.html, "Diversão com strings":diversao-com-strings.html e "Variáveis e atribuição":variaveis-e-atribuicao.html. 69 | <%- page_title, page_url = next_page %> 70 | 71 | -------------------------------------------------------------------------------- /_webby/layouts/default.txt: -------------------------------------------------------------------------------- 1 | --- 2 | extension: html 3 | filter: erb 4 | author: agaelebe 5 | --- 6 | 8 | 9 | 10 | 11 | 12 | <%= @page.title %> 13 | 14 | 15 | 16 | 17 | 18 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 |
31 | 35 | 36 |
37 | <%= @content %> 38 |
39 | 40 |
41 | 42 |

Logo do Guru-SP

43 | 44 |
45 |

Este material tem como base o tutorial do RubyLearning.com de Satish Talim e foi traduzido por membros do GURU-SP com a permissão do autor.

46 |

Ajude o RubyLearning participando em algum dos cursos pagos ou fazendo uma doação para o projeto

47 |
48 | 49 |

Voltar para o índice

50 | 51 |
52 |

53 |
54 | 55 | 59 | 60 |
61 | 62 | 63 | -------------------------------------------------------------------------------- /_webby/lib/breadcrumbs.rb: -------------------------------------------------------------------------------- 1 | # breadcrumbs.rb 2 | 3 | module BreadcrumbsHelper 4 | # call-seq: 5 | # breadcrumbs( page ) => html 6 | # 7 | # Create breadcrumb links for the current page. This will return an HTML 8 | #
    object. 9 | # 10 | def breadcrumbs( page ) 11 | list = ["
  • #{h(page.title)}
    • "] 12 | loop do 13 | page = @pages.parent_of(page) 14 | break if page.nil? 15 | list << "
  • #{link_to_page(page)}
    • " 16 | end 17 | list.reverse! 18 | 19 | html = "
      \n" 20 | html << list.join("\n") 21 | html << "\n
    \n" 22 | html 23 | end 24 | end # module Breadcrumbs 25 | 26 | Webby::Helpers.register(BreadcrumbsHelper) 27 | 28 | 29 | # EOF 30 | -------------------------------------------------------------------------------- /_webby/lib/index.txt: -------------------------------------------------------------------------------- 1 | "Primeiro programa Ruby":primeiro-programa-ruby.html 2 | "Características":caracteristicas.html 3 | "Números em Ruby":numeros-em-ruby.html 4 | "Diversão com strings":diversao-com-strings.html 5 | "Variáveis e atribuição":variaveis-e-atribuicao.html 6 | "Resumo 1":sumario-ruby1.html 7 | "Escopo":escopo.html 8 | "Recebendo entrada":recebendo-entrada.html 9 | "Nomes em Ruby":nomes-em-ruby.html 10 | "Mais sobre métodos Ruby":mais-sobre-metodos.html 11 | "Escrevendo seus métodos Ruby":escrevendo-seus-metodos.html 12 | "Resumo 2":sumario-ruby2.html 13 | "A ferramente ri do Ruby":ruby-ri.html 14 | "Mais sobre Strings":mais-sobre-strings.html 15 | "Construções simples":construcoes-simples.html 16 | "Blocos em Ruby":blocos-ruby.html 17 | "Resumo 3":sumario-ruby3.html 18 | "Arrays Ruby":arrays-ruby.html 19 | "Séries (Ranges)":series.html 20 | "Símbolos em Ruby (Symbols)":simbolos.html 21 | "Hashes (dicionários)":hashes-ruby.html 22 | "Números aleatórios":numeros-aleatorios.html 23 | "Lendo e escrevendo em arquivos":ler-escrever-arquivos.html 24 | "Resumo 4":sumario-ruby4.html 25 | "Expressões Regulares":expressoes-regulares.html 26 | "Escrevendo sua própria classe":escrevendo-sua-propria-classe.html 27 | "Ruby method missing (método faltando)":ruby-method-missing.html 28 | "Procs em Ruby":procs.html 29 | "Incluindo Outros Arquivos":incluindo-outros-arquivos.html 30 | "Classes abertas em Ruby":classes-abertas-em-ruby.html 31 | "Herança":heranca.html 32 | "Sobreposição (Overriding) de Métodos":sobreposicao-de-metodos.html 33 | "Sobrecarregando métodos em Ruby":sobrecarregando-metodos.html 34 | "Resumo 5":sumario-ruby5.html 35 | "Controle de acesso":controle-de-acesso.html 36 | # "Exceções":excecoes.html 37 | "Logging com Ruby":logging-com-ruby.html 38 | "A classe Time do Ruby":classe-time-do-ruby.html 39 | "Resumo 6":sumario-ruby6.html 40 | "Duck Typing":duck-typing.html 41 | "Açúcares sintáticos do Ruby":acucares-sintaticos-do-ruby.html 42 | "Objetos mutáveis e imutáveis":objetos-mutaveis-e-imutaveis.html 43 | "Resumo 7":sumario-ruby7.html 44 | "Serialização de objetos":serializacao-de-objetos.html 45 | "Módulos e Mixins":modulos-mixins.html 46 | "Self":self.html 47 | "Constantes":constantes.html 48 | "Resumo 8":sumario-ruby8.html 49 | -------------------------------------------------------------------------------- /_webby/lib/override.rb: -------------------------------------------------------------------------------- 1 | # From http://www.taknado.com/2007/7/30/overriding-rake-tasks 2 | 3 | Rake::TaskManager.class_eval do 4 | def remove_task(task_name) 5 | @tasks.delete(task_name.to_s) 6 | end 7 | end 8 | 9 | def remove_task(task_name) 10 | Rake.application.remove_task(task_name) 11 | end 12 | 13 | def override_task(args, &block) 14 | name, deps = Rake.application.resolve_args([args]) 15 | remove_task Rake.application[name].name 16 | task(args, &block) 17 | end 18 | 19 | -------------------------------------------------------------------------------- /_webby/lib/pagination.rb: -------------------------------------------------------------------------------- 1 | module Webby 2 | class Renderer 3 | 4 | def self.index_pages 5 | @index ||= {} 6 | if @index.empty? 7 | page = "Ruby - Mais um tutorial?" 8 | File.foreach("lib/index.txt") do |line| 9 | regexp = line.match(/\"(.*)\":(.*)/) 10 | @index[page] = [ regexp[1], regexp[2] ] 11 | page = regexp[1] 12 | end 13 | end 14 | @index 15 | end 16 | 17 | def next_page 18 | Renderer.index_pages[@page.title] || ["Início", "index.html"] 19 | end 20 | 21 | end 22 | end 23 | 24 | -------------------------------------------------------------------------------- /_webby/tasks/github_pages.rake: -------------------------------------------------------------------------------- 1 | # We only want to remove the generated files 2 | desc "Delete the website" 3 | override_task :clobber do |t| 4 | Dir.chdir(Webby.site.output_dir) do 5 | Dir['*'].entries.reject {|entry| entry == '_webby'}.each {|entry| rm_rf entry} 6 | end 7 | end 8 | 9 | desc "Clobber, then build the website" 10 | task :clean_build => [:clobber, :build] 11 | -------------------------------------------------------------------------------- /_webby/templates/_partial.erb: -------------------------------------------------------------------------------- 1 | --- 2 | filter: erb 3 | --- 4 | A partial has access to the page from which it was called. The title below will be the title of the page in which this partial is rendered. 5 | 6 | <%%= h(@page.title) %> 7 | 8 | A partial does not have access to it's own meta-data. The partial meta-data is used primarily for finding partials or for use in other pages. The filter(s) specified in the meta-data will be applied to the partial text when it is rendered. 9 | 10 | A partial does not require meta-data at all. They can contain just text. 11 | -------------------------------------------------------------------------------- /_webby/templates/page.erb: -------------------------------------------------------------------------------- 1 | --- 2 | title: <%= title %> 3 | created_at: <%= Time.now.to_y %> 4 | filter: 5 | - erb 6 | - textile 7 | --- 8 | p(title). <%%= h(@page.title) %> 9 | 10 | Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Nunc congue ipsum vestibulum libero. Aenean vitae justo. Nam eget tellus. Etiam convallis, est eu lobortis mattis, lectus tellus tempus felis, a ultricies erat ipsum at metus. 11 | 12 | h2. Litora Sociis 13 | 14 | Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Morbi et risus. Aliquam nisl. Nulla facilisi. Cras accumsan vestibulum ante. Vestibulum sed tortor. Praesent tempus fringilla elit. Ut elit diam, sagittis in, nonummy in, gravida non, nunc. Ut orci. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos hymenaeos. Nam egestas, orci eu imperdiet malesuada, nisl purus fringilla odio, quis commodo est orci vitae justo. Aliquam placerat odio tincidunt nulla. Cras in libero. Aenean rutrum, magna non tristique posuere, erat odio eleifend nisl, non convallis est tortor blandit ligula. Nulla id augue. 15 | 16 | bq. Nullam mattis, odio ut tempus facilisis, metus nisl facilisis metus, auctor consectetuer felis ligula nec mauris. Vestibulum odio erat, fermentum at, commodo vitae, ultrices et, urna. Mauris vulputate, mi pulvinar sagittis condimentum, sem nulla aliquam velit, sed imperdiet mi purus eu magna. Nulla varius metus ut eros. Aenean aliquet magna eget orci. Class aptent taciti sociosqu ad litora. 17 | 18 | Vivamus euismod. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Suspendisse vel nibh ut turpis dictum sagittis. Aliquam vel velit a elit auctor sollicitudin. Nam vel dui vel neque lacinia pretium. Quisque nunc erat, venenatis id, volutpat ut, scelerisque sed, diam. Mauris ante. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Donec mattis. Morbi dignissim sollicitudin libero. Nulla lorem. 19 | -------------------------------------------------------------------------------- /css/blueprint/ie.css: -------------------------------------------------------------------------------- 1 | /* ----------------------------------------------------------------------- 2 | 3 | 4 | Blueprint CSS Framework 0.8 5 | http://blueprintcss.org 6 | 7 | * Copyright (c) 2007-Present. See LICENSE for more info. 8 | * See README for instructions on how to use Blueprint. 9 | * For credits and origins, see AUTHORS. 10 | * This is a compressed file. See the sources in the 'src' directory. 11 | 12 | ----------------------------------------------------------------------- */ 13 | 14 | /* ie.css */ 15 | body {text-align:center;} 16 | .container {text-align:left;} 17 | * html .column, * html div.span-1, * html div.span-2, * html div.span-3, * html div.span-4, * html div.span-5, * html div.span-6, * html div.span-7, * html div.span-8, * html div.span-9, * html div.span-10, * html div.span-11, * html div.span-12, * html div.span-13, * html div.span-14, * html div.span-15, * html div.span-16, * html div.span-17, * html div.span-18, * html div.span-19, * html div.span-20, * html div.span-21, * html div.span-22, * html div.span-23, * html div.span-24 {overflow-x:hidden;} 18 | * html legend {margin:-18px -8px 16px 0;padding:0;} 19 | ol {margin-left:2em;} 20 | sup {vertical-align:text-top;} 21 | sub {vertical-align:text-bottom;} 22 | html>body p code {*white-space:normal;} 23 | hr {margin:-8px auto 11px;} 24 | .clearfix, .container {display:inline-block;} 25 | * html .clearfix, * html .container {height:1%;} 26 | fieldset {padding-top:0;} -------------------------------------------------------------------------------- /css/blueprint/plugins/buttons/icons/cross.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/buttons/icons/cross.png -------------------------------------------------------------------------------- /css/blueprint/plugins/buttons/icons/key.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/buttons/icons/key.png -------------------------------------------------------------------------------- /css/blueprint/plugins/buttons/icons/tick.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/buttons/icons/tick.png -------------------------------------------------------------------------------- /css/blueprint/plugins/buttons/readme.txt: -------------------------------------------------------------------------------- 1 | Buttons 2 | 3 | * Gives you great looking CSS buttons, for both and 25 | 26 | 27 | Change Password 28 | 29 | 30 | 31 | Cancel 32 | 33 | -------------------------------------------------------------------------------- /css/blueprint/plugins/buttons/screen.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | buttons.css 4 | * Gives you some great CSS-only buttons. 5 | 6 | Created by Kevin Hale [particletree.com] 7 | * particletree.com/features/rediscovering-the-button-element 8 | 9 | See Readme.txt in this folder for instructions. 10 | 11 | -------------------------------------------------------------- */ 12 | 13 | a.button, button { 14 | display:block; 15 | float:left; 16 | margin: 0.7em 0.5em 0.7em 0; 17 | padding:5px 10px 5px 7px; /* Links */ 18 | 19 | border:1px solid #dedede; 20 | border-top:1px solid #eee; 21 | border-left:1px solid #eee; 22 | 23 | background-color:#f5f5f5; 24 | font-family:"Lucida Grande", Tahoma, Arial, Verdana, sans-serif; 25 | font-size:100%; 26 | line-height:130%; 27 | text-decoration:none; 28 | font-weight:bold; 29 | color:#565656; 30 | cursor:pointer; 31 | } 32 | button { 33 | width:auto; 34 | overflow:visible; 35 | padding:4px 10px 3px 7px; /* IE6 */ 36 | } 37 | button[type] { 38 | padding:4px 10px 4px 7px; /* Firefox */ 39 | line-height:17px; /* Safari */ 40 | } 41 | *:first-child+html button[type] { 42 | padding:4px 10px 3px 7px; /* IE7 */ 43 | } 44 | button img, a.button img{ 45 | margin:0 3px -3px 0 !important; 46 | padding:0; 47 | border:none; 48 | width:16px; 49 | height:16px; 50 | float:none; 51 | } 52 | 53 | 54 | /* Button colors 55 | -------------------------------------------------------------- */ 56 | 57 | /* Standard */ 58 | button:hover, a.button:hover{ 59 | background-color:#dff4ff; 60 | border:1px solid #c2e1ef; 61 | color:#336699; 62 | } 63 | a.button:active{ 64 | background-color:#6299c5; 65 | border:1px solid #6299c5; 66 | color:#fff; 67 | } 68 | 69 | /* Positive */ 70 | body .positive { 71 | color:#529214; 72 | } 73 | a.positive:hover, button.positive:hover { 74 | background-color:#E6EFC2; 75 | border:1px solid #C6D880; 76 | color:#529214; 77 | } 78 | a.positive:active { 79 | background-color:#529214; 80 | border:1px solid #529214; 81 | color:#fff; 82 | } 83 | 84 | /* Negative */ 85 | body .negative { 86 | color:#d12f19; 87 | } 88 | a.negative:hover, button.negative:hover { 89 | background:#fbe3e4; 90 | border:1px solid #fbc2c4; 91 | color:#d12f19; 92 | } 93 | a.negative:active { 94 | background-color:#d12f19; 95 | border:1px solid #d12f19; 96 | color:#fff; 97 | } 98 | -------------------------------------------------------------------------------- /css/blueprint/plugins/fancy-type/readme.txt: -------------------------------------------------------------------------------- 1 | Fancy Type 2 | 3 | * Gives you classes to use if you'd like some 4 | extra fancy typography. 5 | 6 | Credits and instructions are specified above each class 7 | in the fancy-type.css file in this directory. 8 | 9 | 10 | Usage 11 | ---------------------------------------------------------------- 12 | 13 | 1) Add this plugin to lib/settings.yml. 14 | See compress.rb for instructions. 15 | -------------------------------------------------------------------------------- /css/blueprint/plugins/fancy-type/screen.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | fancy-type.css 4 | * Lots of pretty advanced classes for manipulating text. 5 | 6 | See the Readme file in this folder for additional instructions. 7 | 8 | -------------------------------------------------------------- */ 9 | 10 | /* Indentation instead of line shifts for sibling paragraphs. */ 11 | p + p { text-indent:2em; margin-top:-1.5em; } 12 | form p + p { text-indent: 0; } /* Don't want this in forms. */ 13 | 14 | 15 | /* For great looking type, use this code instead of asdf: 16 | asdf 17 | Best used on prepositions and ampersands. */ 18 | 19 | .alt { 20 | color: #666; 21 | font-family: "Warnock Pro", "Goudy Old Style","Palatino","Book Antiqua", Georgia, serif; 22 | font-style: italic; 23 | font-weight: normal; 24 | } 25 | 26 | 27 | /* For great looking quote marks in titles, replace "asdf" with: 28 | “asdf” 29 | (That is, when the title starts with a quote mark). 30 | (You may have to change this value depending on your font size). */ 31 | 32 | .dquo { margin-left: -.5em; } 33 | 34 | 35 | /* Reduced size type with incremental leading 36 | (http://www.markboulton.co.uk/journal/comments/incremental_leading/) 37 | 38 | This could be used for side notes. For smaller type, you don't necessarily want to 39 | follow the 1.5x vertical rhythm -- the line-height is too much. 40 | 41 | Using this class, it reduces your font size and line-height so that for 42 | every four lines of normal sized type, there is five lines of the sidenote. eg: 43 | 44 | New type size in em's: 45 | 10px (wanted side note size) / 12px (existing base size) = 0.8333 (new type size in ems) 46 | 47 | New line-height value: 48 | 12px x 1.5 = 18px (old line-height) 49 | 18px x 4 = 72px 50 | 72px / 5 = 14.4px (new line height) 51 | 14.4px / 10px = 1.44 (new line height in em's) */ 52 | 53 | p.incr, .incr p { 54 | font-size: 10px; 55 | line-height: 1.44em; 56 | margin-bottom: 1.5em; 57 | } 58 | 59 | 60 | /* Surround uppercase words and abbreviations with this class. 61 | Based on work by Jørgen Arnor Gårdsø Lom [http://twistedintellect.com/] */ 62 | 63 | .caps { 64 | font-variant: small-caps; 65 | letter-spacing: 1px; 66 | text-transform: lowercase; 67 | font-size:1.2em; 68 | line-height:1%; 69 | font-weight:bold; 70 | padding:0 2px; 71 | } 72 | -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/icons/doc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/link-icons/icons/doc.png -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/icons/email.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/link-icons/icons/email.png -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/icons/external.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/link-icons/icons/external.png -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/icons/feed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/link-icons/icons/feed.png -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/icons/im.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/link-icons/icons/im.png -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/icons/pdf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/link-icons/icons/pdf.png -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/icons/visited.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/link-icons/icons/visited.png -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/icons/xls.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/plugins/link-icons/icons/xls.png -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/readme.txt: -------------------------------------------------------------------------------- 1 | Link Icons 2 | * Icons for links based on protocol or file type. 3 | 4 | This is not supported in IE versions < 7. 5 | 6 | 7 | Credits 8 | ---------------------------------------------------------------- 9 | 10 | * Marc Morgan 11 | * Olav Bjorkoy [bjorkoy.com] 12 | 13 | 14 | Usage 15 | ---------------------------------------------------------------- 16 | 17 | 1) Add this line to your HTML: 18 | -------------------------------------------------------------------------------- /css/blueprint/plugins/link-icons/screen.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | link-icons.css 4 | * Icons for links based on protocol or file type. 5 | 6 | See the Readme file in this folder for additional instructions. 7 | 8 | -------------------------------------------------------------- */ 9 | 10 | /* Use this class if a link gets an icon when it shouldn't. */ 11 | body a.noicon { 12 | background:transparent none !important; 13 | padding:0 !important; 14 | margin:0 !important; 15 | } 16 | 17 | /* Make sure the icons are not cut */ 18 | a[href^="http:"], a[href^="mailto:"], a[href^="http:"]:visited, 19 | a[href$=".pdf"], a[href$=".doc"], a[href$=".xls"], a[href$=".rss"], 20 | a[href$=".rdf"], a[href^="aim:"] { 21 | padding:2px 22px 2px 0; 22 | margin:-2px 0; 23 | background-repeat: no-repeat; 24 | background-position: right center; 25 | } 26 | 27 | /* External links */ 28 | a[href^="http:"] { background-image: url(icons/external.png); } 29 | a[href^="mailto:"] { background-image: url(icons/email.png); } 30 | a[href^="http:"]:visited { background-image: url(icons/visited.png); } 31 | 32 | /* Files */ 33 | a[href$=".pdf"] { background-image: url(icons/pdf.png); } 34 | a[href$=".doc"] { background-image: url(icons/doc.png); } 35 | a[href$=".xls"] { background-image: url(icons/xls.png); } 36 | 37 | /* Misc */ 38 | a[href$=".rss"], 39 | a[href$=".rdf"] { background-image: url(icons/feed.png); } 40 | a[href^="aim:"] { background-image: url(icons/im.png); } -------------------------------------------------------------------------------- /css/blueprint/plugins/rtl/readme.txt: -------------------------------------------------------------------------------- 1 | RTL 2 | * Mirrors Blueprint, so it can be used with Right-to-Left languages. 3 | 4 | By Ran Yaniv Hartstein, ranh.co.il 5 | 6 | Usage 7 | ---------------------------------------------------------------- 8 | 9 | 1) Add this line to your HTML: 10 | -------------------------------------------------------------------------------- /css/blueprint/plugins/rtl/screen.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | rtl.css 4 | * Mirrors Blueprint for left-to-right languages 5 | 6 | By Ran Yaniv Hartstein [ranh.co.il] 7 | 8 | -------------------------------------------------------------- */ 9 | 10 | body .container { direction: rtl; } 11 | body .column { 12 | float: right; 13 | margin-right: 0; 14 | margin-left: 10px; 15 | } 16 | 17 | body .last { margin-left: 0; } 18 | body table .last { padding-left: 0; } 19 | 20 | body .append-1 { padding-right: 0; padding-left: 40px; } 21 | body .append-2 { padding-right: 0; padding-left: 80px; } 22 | body .append-3 { padding-right: 0; padding-left: 120px; } 23 | body .append-4 { padding-right: 0; padding-left: 160px; } 24 | body .append-5 { padding-right: 0; padding-left: 200px; } 25 | body .append-6 { padding-right: 0; padding-left: 240px; } 26 | body .append-7 { padding-right: 0; padding-left: 280px; } 27 | body .append-8 { padding-right: 0; padding-left: 320px; } 28 | body .append-9 { padding-right: 0; padding-left: 360px; } 29 | body .append-10 { padding-right: 0; padding-left: 400px; } 30 | body .append-11 { padding-right: 0; padding-left: 440px; } 31 | body .append-12 { padding-right: 0; padding-left: 480px; } 32 | body .append-13 { padding-right: 0; padding-left: 520px; } 33 | body .append-14 { padding-right: 0; padding-left: 560px; } 34 | body .append-15 { padding-right: 0; padding-left: 600px; } 35 | body .append-16 { padding-right: 0; padding-left: 640px; } 36 | body .append-17 { padding-right: 0; padding-left: 680px; } 37 | body .append-18 { padding-right: 0; padding-left: 720px; } 38 | body .append-19 { padding-right: 0; padding-left: 760px; } 39 | body .append-20 { padding-right: 0; padding-left: 800px; } 40 | body .append-21 { padding-right: 0; padding-left: 840px; } 41 | body .append-22 { padding-right: 0; padding-left: 880px; } 42 | body .append-23 { padding-right: 0; padding-left: 920px; } 43 | 44 | body .prepend-1 { padding-left: 0; padding-right: 40px; } 45 | body .prepend-2 { padding-left: 0; padding-right: 80px; } 46 | body .prepend-3 { padding-left: 0; padding-right: 120px; } 47 | body .prepend-4 { padding-left: 0; padding-right: 160px; } 48 | body .prepend-5 { padding-left: 0; padding-right: 200px; } 49 | body .prepend-6 { padding-left: 0; padding-right: 240px; } 50 | body .prepend-7 { padding-left: 0; padding-right: 280px; } 51 | body .prepend-8 { padding-left: 0; padding-right: 320px; } 52 | body .prepend-9 { padding-left: 0; padding-right: 360px; } 53 | body .prepend-10 { padding-left: 0; padding-right: 400px; } 54 | body .prepend-11 { padding-left: 0; padding-right: 440px; } 55 | body .prepend-12 { padding-left: 0; padding-right: 480px; } 56 | body .prepend-13 { padding-left: 0; padding-right: 520px; } 57 | body .prepend-14 { padding-left: 0; padding-right: 560px; } 58 | body .prepend-15 { padding-left: 0; padding-right: 600px; } 59 | body .prepend-16 { padding-left: 0; padding-right: 640px; } 60 | body .prepend-17 { padding-left: 0; padding-right: 680px; } 61 | body .prepend-18 { padding-left: 0; padding-right: 720px; } 62 | body .prepend-19 { padding-left: 0; padding-right: 760px; } 63 | body .prepend-20 { padding-left: 0; padding-right: 800px; } 64 | body .prepend-21 { padding-left: 0; padding-right: 840px; } 65 | body .prepend-22 { padding-left: 0; padding-right: 880px; } 66 | body .prepend-23 { padding-left: 0; padding-right: 920px; } 67 | 68 | body .border { 69 | padding-right: 0; 70 | padding-left: 4px; 71 | margin-right: 0; 72 | margin-left: 5px; 73 | border-right: none; 74 | border-left: 1px solid #eee; 75 | } 76 | 77 | body .colborder { 78 | padding-right: 0; 79 | padding-left: 24px; 80 | margin-right: 0; 81 | margin-left: 25px; 82 | border-right: none; 83 | border-left: 1px solid #eee; 84 | } 85 | 86 | body .pull-1 { margin-left: 0; margin-right: -40px; } 87 | body .pull-2 { margin-left: 0; margin-right: -80px; } 88 | body .pull-3 { margin-left: 0; margin-right: -120px; } 89 | body .pull-4 { margin-left: 0; margin-right: -160px; } 90 | 91 | body .push-0 { margin: 0 18px 0 0; } 92 | body .push-1 { margin: 0 18px 0 -40px; } 93 | body .push-2 { margin: 0 18px 0 -80px; } 94 | body .push-3 { margin: 0 18px 0 -120px; } 95 | body .push-4 { margin: 0 18px 0 -160px; } 96 | body .push-0, body .push-1, body .push-2, 97 | body .push-3, body .push-4 { float: left; } 98 | 99 | 100 | /* Typography with RTL support */ 101 | body h1,body h2,body h3, 102 | body h4,body h5,body h6 { font-family: Arial, sans-serif; } 103 | html body { font-family: Arial, sans-serif; } 104 | body pre,body code,body tt { font-family: monospace; } 105 | 106 | /* Mirror floats and margins on typographic elements */ 107 | body p img { float: right; margin: 1.5em 0 1.5em 1.5em; } 108 | body dd, body ul, body ol { margin-left: 0; margin-right: 1.5em;} 109 | body td, body th { text-align:right; } -------------------------------------------------------------------------------- /css/blueprint/print.css: -------------------------------------------------------------------------------- 1 | /* ----------------------------------------------------------------------- 2 | 3 | 4 | Blueprint CSS Framework 0.8 5 | http://blueprintcss.org 6 | 7 | * Copyright (c) 2007-Present. See LICENSE for more info. 8 | * See README for instructions on how to use Blueprint. 9 | * For credits and origins, see AUTHORS. 10 | * This is a compressed file. See the sources in the 'src' directory. 11 | 12 | ----------------------------------------------------------------------- */ 13 | 14 | /* print.css */ 15 | body {line-height:1.5;font-family:Helvetica,Arial,sans-serif;color:#000;background:none;font-size:10pt;} 16 | .container {background:none;} 17 | hr {background:#ccc;color:#ccc;width:100%;height:2px;margin:2em 0;padding:0;border:none;} 18 | hr.space {background:#fff;color:#fff;} 19 | h1, h2, h3, h4, h5, h6 {font-family:"Helvetica Neue", Arial, "Lucida Grande", sans-serif;} 20 | code {font:.9em "Courier New", Monaco, Courier, monospace;} 21 | img {float:left;margin:1.5em 1.5em 1.5em 0;} 22 | a img {border:none;} 23 | p img.top {margin-top:0;} 24 | blockquote {margin:1.5em;padding:1em;font-style:italic;font-size:.9em;} 25 | .small {font-size:.9em;} 26 | .large {font-size:1.1em;} 27 | .quiet {color:#999;} 28 | .hide {display:none;} 29 | a:link, a:visited {background:transparent;font-weight:700;text-decoration:underline;} 30 | a:link:after, a:visited:after {content:" (" attr(href) ") ";font-size:90%;} 31 | -------------------------------------------------------------------------------- /css/blueprint/src/forms.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | forms.css 4 | * Sets up some default styling for forms 5 | * Gives you classes to enhance your forms 6 | 7 | Usage: 8 | * For text fields, use class .title or .text 9 | 10 | -------------------------------------------------------------- */ 11 | 12 | label { font-weight: bold; } 13 | fieldset { padding:1.4em; margin: 0 0 1.5em 0; border: 1px solid #ccc; } 14 | legend { font-weight: bold; font-size:1.2em; } 15 | 16 | 17 | /* Form fields 18 | -------------------------------------------------------------- */ 19 | 20 | input.text, input.title, 21 | textarea, select { 22 | margin:0.5em 0; 23 | border:1px solid #bbb; 24 | } 25 | 26 | input.text:focus, input.title:focus, 27 | textarea:focus, select:focus { 28 | border:1px solid #666; 29 | } 30 | 31 | input.text, 32 | input.title { width: 300px; padding:5px; } 33 | input.title { font-size:1.5em; } 34 | textarea { width: 390px; height: 250px; padding:5px; } 35 | 36 | 37 | /* Success, notice and error boxes 38 | -------------------------------------------------------------- */ 39 | 40 | .error, 41 | .notice, 42 | .success { padding: .8em; margin-bottom: 1em; border: 2px solid #ddd; } 43 | 44 | .error { background: #FBE3E4; color: #8a1f11; border-color: #FBC2C4; } 45 | .notice { background: #FFF6BF; color: #514721; border-color: #FFD324; } 46 | .success { background: #E6EFC2; color: #264409; border-color: #C6D880; } 47 | .error a { color: #8a1f11; } 48 | .notice a { color: #514721; } 49 | .success a { color: #264409; } 50 | -------------------------------------------------------------------------------- /css/blueprint/src/grid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/css/blueprint/src/grid.png -------------------------------------------------------------------------------- /css/blueprint/src/ie.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | ie.css 4 | 5 | Contains every hack for Internet Explorer, 6 | so that our core files stay sweet and nimble. 7 | 8 | -------------------------------------------------------------- */ 9 | 10 | /* Make sure the layout is centered in IE5 */ 11 | body { text-align: center; } 12 | .container { text-align: left; } 13 | 14 | /* Fixes IE margin bugs */ 15 | * html .column, * html div.span-1, * html div.span-2, 16 | * html div.span-3, * html div.span-4, * html div.span-5, 17 | * html div.span-6, * html div.span-7, * html div.span-8, 18 | * html div.span-9, * html div.span-10, * html div.span-11, 19 | * html div.span-12, * html div.span-13, * html div.span-14, 20 | * html div.span-15, * html div.span-16, * html div.span-17, 21 | * html div.span-18, * html div.span-19, * html div.span-20, 22 | * html div.span-21, * html div.span-22, * html div.span-23, 23 | * html div.span-24 { overflow-x: hidden; } 24 | 25 | 26 | /* Elements 27 | -------------------------------------------------------------- */ 28 | 29 | /* Fixes incorrect styling of legend in IE6. */ 30 | * html legend { margin:-18px -8px 16px 0; padding:0; } 31 | 32 | /* Fixes incorrect placement of ol numbers in IE6/7. */ 33 | ol { margin-left:2em; } 34 | 35 | /* Fixes wrong line-height on sup/sub in IE. */ 36 | sup { vertical-align: text-top; } 37 | sub { vertical-align: text-bottom; } 38 | 39 | /* Fixes IE7 missing wrapping of code elements. */ 40 | html>body p code { *white-space: normal; } 41 | 42 | /* IE 6&7 has problems with setting proper
    margins. */ 43 | hr { margin: -8px auto 11px; } 44 | 45 | 46 | /* Clearing 47 | -------------------------------------------------------------- */ 48 | 49 | /* Makes clearfix actually work in IE */ 50 | .clearfix, .container {display: inline-block;} 51 | * html .clearfix, 52 | * html .container {height: 1%;} 53 | 54 | 55 | /* Forms 56 | -------------------------------------------------------------- */ 57 | 58 | /* Fixes padding on fieldset */ 59 | fieldset {padding-top: 0;} -------------------------------------------------------------------------------- /css/blueprint/src/print.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | print.css 4 | * Gives you some sensible styles for printing pages. 5 | * See Readme file in this directory for further instructions. 6 | 7 | Some additions you'll want to make, customized to your markup: 8 | #header, #footer, #navigation { display:none; } 9 | 10 | -------------------------------------------------------------- */ 11 | 12 | body { 13 | line-height: 1.5; 14 | font-family: "Helvetica Neue", Arial, Helvetica, sans-serif; 15 | color:#000; 16 | background: none; 17 | font-size: 10pt; 18 | } 19 | 20 | 21 | /* Layout 22 | -------------------------------------------------------------- */ 23 | 24 | .container { 25 | background: none; 26 | } 27 | 28 | hr { 29 | background:#ccc; 30 | color:#ccc; 31 | width:100%; 32 | height:2px; 33 | margin:2em 0; 34 | padding:0; 35 | border:none; 36 | } 37 | hr.space { 38 | background: #fff; 39 | color: #fff; 40 | } 41 | 42 | 43 | /* Text 44 | -------------------------------------------------------------- */ 45 | 46 | h1,h2,h3,h4,h5,h6 { font-family: "Helvetica Neue", Arial, "Lucida Grande", sans-serif; } 47 | code { font:.9em "Courier New", Monaco, Courier, monospace; } 48 | 49 | img { float:left; margin:1.5em 1.5em 1.5em 0; } 50 | a img { border:none; } 51 | p img.top { margin-top: 0; } 52 | 53 | blockquote { 54 | margin:1.5em; 55 | padding:1em; 56 | font-style:italic; 57 | font-size:.9em; 58 | } 59 | 60 | .small { font-size: .9em; } 61 | .large { font-size: 1.1em; } 62 | .quiet { color: #999; } 63 | .hide { display:none; } 64 | 65 | 66 | /* Links 67 | -------------------------------------------------------------- */ 68 | 69 | a:link, a:visited { 70 | background: transparent; 71 | font-weight:700; 72 | text-decoration: underline; 73 | } 74 | 75 | a:link:after, a:visited:after { 76 | content: " (" attr(href) ") "; 77 | font-size: 90%; 78 | } 79 | 80 | /* If you're having trouble printing relative links, uncomment and customize this: 81 | (note: This is valid CSS3, but it still won't go through the W3C CSS Validator) */ 82 | 83 | /* a[href^="/"]:after { 84 | content: " (http://www.yourdomain.com" attr(href) ") "; 85 | } */ 86 | -------------------------------------------------------------------------------- /css/blueprint/src/reset.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | reset.css 4 | * Resets default browser CSS. 5 | 6 | -------------------------------------------------------------- */ 7 | 8 | html, body, div, span, object, iframe, 9 | h1, h2, h3, h4, h5, h6, p, blockquote, pre, 10 | a, abbr, acronym, address, code, 11 | del, dfn, em, img, q, dl, dt, dd, ol, ul, li, 12 | fieldset, form, label, legend, 13 | table, caption, tbody, tfoot, thead, tr, th, td { 14 | margin: 0; 15 | padding: 0; 16 | border: 0; 17 | font-weight: inherit; 18 | font-style: inherit; 19 | font-size: 100%; 20 | font-family: inherit; 21 | vertical-align: baseline; 22 | } 23 | 24 | body { 25 | line-height: 1.5; 26 | } 27 | 28 | /* Tables still need 'cellspacing="0"' in the markup. */ 29 | table { border-collapse: separate; border-spacing: 0; } 30 | caption, th, td { text-align: left; font-weight: normal; } 31 | table, td, th { vertical-align: middle; } 32 | 33 | /* Remove possible quote marks (") from ,
    . */ 34 | blockquote:before, blockquote:after, q:before, q:after { content: ""; } 35 | blockquote, q { quotes: "" ""; } 36 | 37 | /* Remove annoying border on linked images. */ 38 | a img { border: none; } 39 | -------------------------------------------------------------------------------- /css/blueprint/src/typography.css: -------------------------------------------------------------------------------- 1 | /* -------------------------------------------------------------- 2 | 3 | typography.css 4 | * Sets up some sensible default typography. 5 | 6 | -------------------------------------------------------------- */ 7 | 8 | /* Default font settings. 9 | The font-size percentage is of 16px. (0.75 * 16px = 12px) */ 10 | body { 11 | font-size: 75%; 12 | color: #222; 13 | background: #fff; 14 | font-family: "Helvetica Neue", Arial, Helvetica, sans-serif; 15 | } 16 | 17 | 18 | /* Headings 19 | -------------------------------------------------------------- */ 20 | 21 | h1,h2,h3,h4,h5,h6 { font-weight: normal; color: #111; } 22 | 23 | h1 { font-size: 3em; line-height: 1; margin-bottom: 0.5em; } 24 | h2 { font-size: 2em; margin-bottom: 0.75em; } 25 | h3 { font-size: 1.5em; line-height: 1; margin-bottom: 1em; } 26 | h4 { font-size: 1.2em; line-height: 1.25; margin-bottom: 1.25em; } 27 | h5 { font-size: 1em; font-weight: bold; margin-bottom: 1.5em; } 28 | h6 { font-size: 1em; font-weight: bold; } 29 | 30 | h1 img, h2 img, h3 img, 31 | h4 img, h5 img, h6 img { 32 | margin: 0; 33 | } 34 | 35 | 36 | /* Text elements 37 | -------------------------------------------------------------- */ 38 | 39 | p { margin: 0 0 1.5em; } 40 | p img.left { float: left; margin: 1.5em 1.5em 1.5em 0; padding: 0; } 41 | p img.right { float: right; margin: 1.5em 0 1.5em 1.5em; } 42 | 43 | a:focus, 44 | a:hover { color: #000; } 45 | a { color: #009; text-decoration: underline; } 46 | 47 | blockquote { margin: 1.5em; color: #666; font-style: italic; } 48 | strong { font-weight: bold; } 49 | em,dfn { font-style: italic; } 50 | dfn { font-weight: bold; } 51 | sup, sub { line-height: 0; } 52 | 53 | abbr, 54 | acronym { border-bottom: 1px dotted #666; } 55 | address { margin: 0 0 1.5em; font-style: italic; } 56 | del { color:#666; } 57 | 58 | pre { margin: 1.5em 0; white-space: pre; } 59 | pre,code,tt { font: 1em 'andale mono', 'lucida console', monospace; line-height: 1.5; } 60 | 61 | 62 | /* Lists 63 | -------------------------------------------------------------- */ 64 | 65 | li ul, 66 | li ol { margin:0 1.5em; } 67 | ul, ol { margin: 0 1.5em 1.5em 1.5em; } 68 | 69 | ul { list-style-type: disc; } 70 | ol { list-style-type: decimal; } 71 | 72 | dl { margin: 0 0 1.5em 0; } 73 | dl dt { font-weight: bold; } 74 | dd { margin-left: 1.5em;} 75 | 76 | 77 | /* Tables 78 | -------------------------------------------------------------- */ 79 | 80 | table { margin-bottom: 1.4em; width:100%; } 81 | th { font-weight: bold; } 82 | thead th { background: #c3d9ff; } 83 | th,td,caption { padding: 4px 10px 4px 5px; } 84 | tr.even td { background: #e5ecf9; } 85 | tfoot { font-style: italic; } 86 | caption { background: #eee; } 87 | 88 | 89 | /* Misc classes 90 | -------------------------------------------------------------- */ 91 | 92 | .small { font-size: .8em; margin-bottom: 1.875em; line-height: 1.875em; } 93 | .large { font-size: 1.2em; line-height: 2.5em; margin-bottom: 1.25em; } 94 | .hide { display: none; } 95 | 96 | .quiet { color: #666; } 97 | .loud { color: #000; } 98 | .highlight { background:#ff0; } 99 | .added { background:#060; color: #fff; } 100 | .removed { background:#900; color: #fff; } 101 | 102 | .first { margin-left:0; padding-left:0; } 103 | .last { margin-right:0; padding-right:0; } 104 | .top { margin-top:0; padding-top:0; } 105 | .bottom { margin-bottom:0; padding-bottom:0; } 106 | -------------------------------------------------------------------------------- /css/coderay.css: -------------------------------------------------------------------------------- 1 | .CodeRay { 2 | padding: 0.5em; 3 | margin-bottom: 1.3em; 4 | background-color: #eee; 5 | border: 1px solid #aaa; 6 | font: 1.1em "Monaco","Bitstream Vera Sans Mono","Courier New",serif; 7 | color: #100; 8 | } 9 | .CodeRay pre { 10 | padding: 0px; 11 | margin: 0px; 12 | overflow: auto; 13 | background-color: transparent; 14 | border: none; 15 | } 16 | 17 | 18 | div.CodeRay { } 19 | 20 | span.CodeRay { white-space: pre; border: 0px; padding: 2px;} 21 | 22 | table.CodeRay { border-collapse: collapse; width: 100%; padding: 2px } 23 | table.CodeRay td { padding: 2px 4px; vertical-align: top } 24 | 25 | .CodeRay .line_numbers, .CodeRay .no { 26 | background-color: #DDD; 27 | color: #333; 28 | text-align: right; 29 | } 30 | .CodeRay .line_numbers tt { font-weight: bold } 31 | .CodeRay .no { padding: 0px 4px } 32 | 33 | ol.CodeRay { font-size: 10pt } 34 | ol.CodeRay li { white-space: pre } 35 | 36 | .CodeRay .debug { color:white ! important; background:blue ! important; } 37 | 38 | .CodeRay .af { color:#00C } 39 | .CodeRay .an { color:#007 } 40 | .CodeRay .av { color:#700 } 41 | .CodeRay .aw { color:#C00 } 42 | .CodeRay .bi { color:#509; font-weight:bold } 43 | .CodeRay .c { color:#666; } 44 | 45 | .CodeRay .ch { color:#04D } 46 | .CodeRay .ch .k { color:#04D } 47 | .CodeRay .ch .dl { color:#039 } 48 | 49 | .CodeRay .cl { color:#B06; font-weight:bold } 50 | .CodeRay .co { color:#036; font-weight:bold } 51 | .CodeRay .cr { color:#0A0 } 52 | .CodeRay .cv { color:#369 } 53 | .CodeRay .df { color:#099; font-weight:bold } 54 | .CodeRay .di { color:#088; font-weight:bold } 55 | .CodeRay .dl { color:black } 56 | .CodeRay .do { color:#970 } 57 | .CodeRay .ds { color:#D42; font-weight:bold } 58 | .CodeRay .e { color:#666; font-weight:bold } 59 | .CodeRay .en { color:#800; font-weight:bold } 60 | .CodeRay .er { color:#F00; background-color:#FAA } 61 | .CodeRay .ex { color:#F00; font-weight:bold } 62 | .CodeRay .fl { color:#60E; font-weight:bold } 63 | .CodeRay .fu { color:#06B; font-weight:bold } 64 | .CodeRay .gv { color:#d70; font-weight:bold } 65 | .CodeRay .hx { color:#058; font-weight:bold } 66 | .CodeRay .i { color:#00D; font-weight:bold } 67 | .CodeRay .ic { color:#B44; font-weight:bold } 68 | 69 | .CodeRay .il { background: #eee } 70 | .CodeRay .il .il { background: #ddd } 71 | .CodeRay .il .il .il { background: #ccc } 72 | .CodeRay .il .idl { font-weight: bold; color: #888 } 73 | 74 | .CodeRay .in { color:#B2B; font-weight:bold } 75 | .CodeRay .iv { color:#33B } 76 | .CodeRay .la { color:#970; font-weight:bold } 77 | .CodeRay .lv { color:#963 } 78 | .CodeRay .oc { color:#40E; font-weight:bold } 79 | .CodeRay .of { color:#000; font-weight:bold } 80 | .CodeRay .op { } 81 | .CodeRay .pc { color:#038; font-weight:bold } 82 | .CodeRay .pd { color:#369; font-weight:bold } 83 | .CodeRay .pp { color:#579 } 84 | .CodeRay .pt { color:#339; font-weight:bold } 85 | .CodeRay .r { color:#080; font-weight:bold } 86 | 87 | .CodeRay .rx { background-color:#fff0ff } 88 | .CodeRay .rx .k { color:#808 } 89 | .CodeRay .rx .dl { color:#404 } 90 | .CodeRay .rx .mod { color:#C2C } 91 | .CodeRay .rx .fu { color:#404; font-weight: bold } 92 | 93 | .CodeRay .s { background-color:#fff0f0 } 94 | .CodeRay .s .s { background-color:#ffe0e0 } 95 | .CodeRay .s .s .s { background-color:#ffd0d0 } 96 | .CodeRay .s .k { color:#D20 } 97 | .CodeRay .s .dl { color:#710 } 98 | 99 | .CodeRay .sh { background-color:#f0fff0 } 100 | .CodeRay .sh .k { color:#2B2 } 101 | .CodeRay .sh .dl { color:#161 } 102 | 103 | .CodeRay .sy { color:#A60 } 104 | .CodeRay .sy .k { color:#A60 } 105 | .CodeRay .sy .dl { color:#630 } 106 | 107 | .CodeRay .ta { color:#070 } 108 | .CodeRay .tf { color:#070; font-weight:bold } 109 | .CodeRay .ts { color:#D70; font-weight:bold } 110 | .CodeRay .ty { color:#339; font-weight:bold } 111 | .CodeRay .v { color:#036 } 112 | .CodeRay .xt { color:#444 } 113 | -------------------------------------------------------------------------------- /css/site.css: -------------------------------------------------------------------------------- 1 | 2 | body { 3 | font-family: Verdana, "Bitstream Vera Sans", sans-serif; 4 | } 5 | 6 | /* Headings 7 | * --------------------------------------------------------------------- */ 8 | h1,h2,h3,h4,h5,h6 { color: #111; } 9 | 10 | /* Text Elements 11 | * --------------------------------------------------------------------- */ 12 | a { color: #125AA7; } 13 | a:hover { color: #000; } 14 | blockquote { color: #666; } 15 | 16 | pre { 17 | background: #e0e0e0; 18 | border: 1px solid #ddd; 19 | } 20 | 21 | hr { 22 | background: #D82925; 23 | color: #D82925; 24 | } 25 | 26 | /* Tables 27 | * --------------------------------------------------------------------- */ 28 | table { 29 | border-top: 1px solid #ddd; 30 | border-left: 1px solid #ddd; 31 | } 32 | th,td { 33 | border-bottom: 1px solid #ddd; 34 | border-right: 1px solid #ddd; 35 | } 36 | 37 | /* Default Classes 38 | * --------------------------------------------------------------------- */ 39 | p.quiet { color: #666; } 40 | .alt { color: #666; } 41 | 42 | p.title { 43 | color: #111; 44 | font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; 45 | font-size: 2em; 46 | margin-bottom: 0.75em; 47 | } 48 | 49 | #header .title { 50 | font-size: 3em; 51 | line-height: 1; 52 | margin: 0.5em 0 0.25em 0; } 53 | #header a { 54 | text-decoration: none; 55 | color: #333; 56 | } 57 | 58 | .box { 59 | background: #FFF3CF; 60 | margin: 10px 0 10px 0; 61 | padding: 5px 15px 5px 15px; 62 | border: 1px solid #FC0; 63 | } 64 | 65 | .box p{ 66 | padding: 0; 67 | margin: 5px 0 5px 0; 68 | } 69 | 70 | .pagination { 71 | text-align: right; 72 | padding: 5px; 73 | margin: 5px; 74 | } 75 | 76 | /* EOF */ 77 | -------------------------------------------------------------------------------- /escopo.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | Escopo 8 | 9 | 10 | 11 | 12 | 13 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 |
    26 | 30 | 31 |
    32 |

    Escopo

    33 |

    Escopo refere-se ao alcance de visibilidade das variáveis. Diferentes tipos de variáveis tem diferentes regras de escopo. Nós estaremos falando principalmente sobre dois tipos: variáveis globais e locais.

    34 |

    Escopo global e variáveis globais

    35 |

    Nós estamos começando com o escopo que é utilizado com menos frequência, mas que você precisa ficar ciente que: escopo global significa que cobre todo o programa. O escopo global é desfrutado por variáveis globais. Variáveis globais são distinguidas por começarem com um sinal de dólar ($). Elas são disponíveis em qualquer lugar do programa. Variáveis globais nunca saem do escopo. Entretanto, variáveis globais são utilizadas muito poucas vezes por programadores experientes (exceto, talvez, aquelas que já vem embutidas).

    36 |

    Variáveis globais embutidas

    37 |

    O interpretador do Ruby trás um relativamente grande número de variáveis globais inicializadas. Essas variáveis armazenam informações que possuem potencial usabilidade em todo e qualquer lugar em seu programa. Por exemplo, a variável global $0 contém o nome do arquivo Ruby sendo executado. A global $: (dólar seguido de dois pontos) contém os diretórios que compõem o path onde o Ruby busca quando você carrega um arquivo externo. $$ contém o id do processo no processamento do Ruby. E existem outras.

    38 |

    Escopo local

    39 |

    Nota: Não se preocupe se você não entender essa parte agora.
    40 | Você pode dizer, olhando um programa Ruby, onde o escopo local começa e termina, baseado nas seguintes regras:

    41 |
      42 |
    • O nível mais alto (por fora de todas as definições de bloco) tem seu próprio escopo local.
      • 43 |
    • Cada definição de bloco de classe ou módulo (class, module) tem seu próprio escopo local, mesmo definições de blocos de classes/módulos aninhadas.
      • 44 |
    • Cada definição de bloco de método (def) tem seu próprio escopo local.
      • 45 |
    46 | 47 |
    48 | 49 |
    50 | 51 |

    Logo do Guru-SP

    52 | 53 |
    54 |

    Este material tem como base o tutorial do RubyLearning.com de Satish Talim e foi traduzido por membros do GURU-SP com a permissão do autor.

    55 |

    Ajude o RubyLearning participando em algum dos cursos pagos ou fazendo uma doação para o projeto

    56 |
    57 | 58 |

    Voltar para o índice

    59 | 60 |
    61 |

    62 |
    63 | 64 | 68 | 69 |
    70 | 71 | 72 | -------------------------------------------------------------------------------- /images/exception.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/images/exception.jpg -------------------------------------------------------------------------------- /images/hierarquia_classes.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/images/hierarquia_classes.gif -------------------------------------------------------------------------------- /images/logo_guru-sp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/images/logo_guru-sp.jpg -------------------------------------------------------------------------------- /images/operators.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guru-sp/tutorial_ruby/8cd8d9d8a9cfba230bc15d7b1951ce0d8e8ccba5/images/operators.jpg -------------------------------------------------------------------------------- /mais-sobre-metodos.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | Mais sobre métodos Ruby 8 | 9 | 10 | 11 | 12 | 13 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 |
    26 | 30 | 31 |
    32 |

    Mais sobre métodos Ruby

    33 |

    Se objetos (como strings, inteiros ou floats) são os substantivos na linguagem Ruby, então os métodos são os verbos. Cada método precisa de um objeto. Geralmente é comum dizer qual objeto está executando o método: é o que vem logo antes do ponto. Às vezes, porém, não é tão óbvio assim. Quando estamos usando puts, gets – onde estão os objetos deles? Em Ruby, o objeto implícito é qualquer objeto em que você está no momento. Mas nós nem sabemos ainda como estar em um objeto; Nós sempre estivemos dentro de um objeto especial (main). Ruby o criou para nós e ele representa todo o programa. Você pode sempre ver em que objeto está (objeto corrente) usando a variável especial self.

    34 |
    35 | 
    1  puts self
    36 |
    37 |

    Para mais detalhes sobre self, veja aqui.

    38 | 39 |
    40 | 41 |
    42 | 43 |

    Logo do Guru-SP

    44 | 45 |
    46 |

    Este material tem como base o tutorial do RubyLearning.com de Satish Talim e foi traduzido por membros do GURU-SP com a permissão do autor.

    47 |

    Ajude o RubyLearning participando em algum dos cursos pagos ou fazendo uma doação para o projeto

    48 |
    49 | 50 |

    Voltar para o índice

    51 | 52 |
    53 |

    54 |
    55 | 56 | 60 | 61 |
    62 | 63 | 64 | -------------------------------------------------------------------------------- /recebendo-entrada.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | Recebendo entrada 8 | 9 | 10 | 11 | 12 | 13 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 |
    26 | 30 | 31 |
    32 |

    Recebendo entrada

    33 |

    Páginas atrás vimos o método puts que imprime texto na tela. Agora, como aceitar uma entrada do usuário? Para isso gets (pegar a string) e chomp (mastigar) são úteis. O exemplo p005metodos.rb abaixo ilustra o mesmo.

    34 |
    35 | 
    1 # p005metodos.rb
36 | 2 # gets e chomp
37 | 3 puts "Em qual cidade você está?"
38 | 4 STDOUT.flush
39 | 5 cidade = gets.chomp
40 | 6 puts "A cidade é " + cidade
41 |
    42 |
    43 |

    Quando você executar o exemplo acima no SciTE, clique no caixa de saída (no lado direito do SciTE) e então digite o nome de sua cidade.

    44 |

    STDOUT é uma constante global que é a saída padrão atual do programa. flush (fluir) limpa qualquer dado armazenado no buffer (área de armazenamento temporário de dados) de entrada e saída do Ruby. O uso não é mandatório, mas recomendado.

    45 |

    gets recebe uma linha única de dados da entrada padrão – o teclado nesse caso – e atribui a string digitada pelo usuário à variável cidade.

    46 |

    chomp é um método de string e retorna apenas as strings do que veio do teclado. Você deve ter percebido que gets retorna uma string e o caractere ‘\n’ (quebra de linha), enquanto chomp remove o ‘\n’.

    47 |
    NO RAILS: Os dados vêm de muitas fontes. Em uma aplicação típica do Rails, eles vêm do banco de dados. Como um desenvolvedor Rails, você pode se encontrar utilizando relativamente poucas dessas facilidades, porque o Rails faz o tratamento dos dados para você; e seus usuários, quando eles enviam entradas pelo teclado, estarão geralmente digitando em um formulário web.
    48 | 49 |
    50 | 51 |
    52 | 53 |

    Logo do Guru-SP

    54 | 55 |
    56 |

    Este material tem como base o tutorial do RubyLearning.com de Satish Talim e foi traduzido por membros do GURU-SP com a permissão do autor.

    57 |

    Ajude o RubyLearning participando em algum dos cursos pagos ou fazendo uma doação para o projeto

    58 |
    59 | 60 |

    Voltar para o índice

    61 | 62 |
    63 |

    64 |
    65 | 66 | 70 | 71 |
    72 | 73 | 74 | -------------------------------------------------------------------------------- /ruby-method-missing.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | Ruby method missing (método faltando) 8 | 9 | 10 | 11 | 12 | 13 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 |
    26 | 30 | 31 |
    32 |

    Ruby method missing (método faltando)

    33 |

    Quando você envia uma mensagem a um objeto, este executa o primeiro método que ele encontra no caminho de busca do método (arquivo PDF) com o mesmo nome da mensagem. Se ele falha em encontrar tal método, ele lança uma exceção do tipo NoMethodError – a menos que você tenha fornecido ao objeto um método chamado method_missing (método ausente). Ao método method_missing é passado o símbolo do método não existente, uma lista de argumentos que foram passados na chamada original e qualquer bloco passado ao método original.

    34 |

    method_missing faz parte de uma rede de segurança: Ele lhe fornece um jeito de interceptar mensagens não respondidas e trata-as de maneira elegante. Veja o exemplo p012zmm.rb abaixo:

    35 |
    36 | 
    1 class Dummy
37 | 2   def method_missing(m, *args, &block)  
38 | 3     puts "Não há nenhum método chamado #{m} aqui."  
39 | 4   end  
40 | 5 end  
41 | 6 Dummy.new.qualquer_coisa
42 |
    43 |
    44 |

    A saída é:

    45 |
    46 | 
    1 >ruby p012zmm.rb  
47 | 2 Não há nenhum método chamado qualquer_coisa aqui.  
48 | 3 >Exit code: 0  
49 |
    50 |
    51 |

    Você também é responsável por manter a assinatura do method_missing. É possível escrever um gancho que captura apenas o nome de um método ausente enquanto ignora seus argumentos e o bloco associado.

    52 | 53 |
    54 | 55 |
    56 | 57 |

    Logo do Guru-SP

    58 | 59 |
    60 |

    Este material tem como base o tutorial do RubyLearning.com de Satish Talim e foi traduzido por membros do GURU-SP com a permissão do autor.

    61 |

    Ajude o RubyLearning participando em algum dos cursos pagos ou fazendo uma doação para o projeto

    62 |
    63 | 64 |

    Voltar para o índice

    65 | 66 |
    67 |

    68 |
    69 | 70 | 74 | 75 |
    76 | 77 | 78 | -------------------------------------------------------------------------------- /sumario-ruby7.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | Resumo 7 8 | 9 | 10 | 11 | 12 | 13 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 |
    26 | 30 | 31 |
    32 |

    Resumo 7

    33 |
      34 |
    1. No Ruby, nós dependemos menos do tipo (ou classe) de um objeto e mais em suas capacidades. Deste modo, Duck Typing significa que o tipo de um objeto é definido por aquilo que ele pode fazer, não por aquilo que ele é.
      2. 35 |
    2. Duck Typing se refere a tendência do Ruby de se preocupar menos com a classe de um objeto e mais com quais métodos podem ser chamados nela e quais operações ela suporta.
      3. 36 |
    3. No Ruby, podemos usar respond_to? ou podemos simplesmente passar um objeto para um método e então saber que uma exceção será lançada se for usado inapropriadamente.
      4. 37 |
    4. Açúcares sintáticos (Syntatic Sugars) se referem as regras que permitem a você escrever seu código de modo que ele não corresponda as regras normais mas que seja mais fácil de se lembrar de como fazer e que tenha melhor aparência.
      5. 38 |
    5. Ruby permite que você defina métodos que terminem com um sinal de igual (=).
      6. 39 |
    6. Objetos mutáveis são objetos cujo estado pode mudar. Objetos imutáveis são objetos cujo estado nunca se altera após sua criação.
      7. 40 |
    7. Mutabilidade é a propriedade de uma instância, não de uma classe inteira. Qualquer instância pode se tornar imutável chamando-se o método freeze (congelar).
      8. 41 |
    8. O método freeze na classe Object previne que você altere um objeto, efetivamente transformando-o em uma constante. Após congelarmos um objeto, uma tentativa de modificá-lo resultará em um RuntimeError.
      9. 42 |
    9. freeze opera na referência de um objeto, não em uma variável. Isso significa que qualquer operações resultando em um novo objeto funcionará.
      10. 43 |
    10. O método frozen? lhe diz se um objeto está ou não congelado (é ou não imutável).
      11. 44 |
    45 | 46 |
    47 | 48 |
    49 | 50 |

    Logo do Guru-SP

    51 | 52 |
    53 |

    Este material tem como base o tutorial do RubyLearning.com de Satish Talim e foi traduzido por membros do GURU-SP com a permissão do autor.

    54 |

    Ajude o RubyLearning participando em algum dos cursos pagos ou fazendo uma doação para o projeto

    55 |
    56 | 57 |

    Voltar para o índice

    58 | 59 |
    60 |

    61 |
    62 | 63 | 67 | 68 |
    69 | 70 | 71 | -------------------------------------------------------------------------------- /sumario-ruby8.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | Resumo 8 8 | 9 | 10 | 11 | 12 | 13 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 |
    26 | 30 | 31 |
    32 |

    Resumo 8

    33 |
      34 |
    1. Módulos Ruby são similares a classes em relação ao fato de que também armazenam uma coleção de métodos, constantes e outras definições de módulos e classes. Entretanto, diferente das classes, você não pode criar objetos baseados em módulos; ao invés disso, você especifica qual funcionalidade de um módulo específico você deseja adicionar a uma classe ou a um objeto específico.
      2. 35 |
    2. Módulos tem dois propósitos principais: Primeiro agem como namespace, permitindo que você defina métodos cujos nomes não irão coincidir com outros já definidos. Em segundo lugar, eles permitem que você compartilhe funcionalidade entre classes – se uma classe inclui um módulo, os métodos de instância do módulo ficam disponíveis como se tivessem sido definidos na classe. Eles são ‘misturados’ (mixed in) a classe.
      3. 36 |
    3. Observe como você pode usar require ou load para arquivos e include para os múdulos.
      4. 37 |
    4. Lembre-se que você pode incluir mais de um módulo em uma classe. Entretanto, uma classe não pode herdar de mais de uma classe.
      5. 38 |
    5. Nomes de classe tendem a ser substantivos, enquanto nomes de módulos são com frequência adjetivos.
      6. 39 |
    6. Em cada lugar que seu programa roda, existe um e apenas um self – o objeto atual ou objeto padrão que você tem acesso em seu programa.
      7. 40 |
    7. Observe que as regras dadas para self na página relacionada a Self.
      8. 41 |
    8. O Java possui a habilidade de serializar objetos, permitindo que você os armazene e reconstitua-os quando necessário. O Ruby chama esse tipo de serialização de marshaling (empacotamento).
      9. 42 |
    9. Marshal.dump é usado para salvar uma versão serializada de um objeto.
      10. 43 |
    10. Marshal.load é usado para ler o objeto serializado de um arquivo.
      11. 44 |
    11. Uma constante Ruby é uma referência para um objeto.
      12. 45 |
    12. Embora constantes não devam ser alteradas, você pode modificar o estado interno de objetos referenciados pelas mesmas.
      13. 46 |
    13. Lembre-se das regras para constantes.
      14. 47 |
    48 | 49 |
    50 | 51 |
    52 | 53 |

    Logo do Guru-SP

    54 | 55 |
    56 |

    Este material tem como base o tutorial do RubyLearning.com de Satish Talim e foi traduzido por membros do GURU-SP com a permissão do autor.

    57 |

    Ajude o RubyLearning participando em algum dos cursos pagos ou fazendo uma doação para o projeto

    58 |
    59 | 60 |

    Voltar para o índice

    61 | 62 |
    63 |

    64 |
    65 | 66 | 70 | 71 |
    72 | 73 | 74 | --------------------------------------------------------------------------------