Contudo, com esse objetivo em vista, resolvi utilizar os recursos do ruby para ir de encontro às melhores soluções. E embarcando nessa jornada comecei a dar uma pincelada sobre as solução já existentes no ruby, quando então me deparei com o mais óbvio: as gems - Você já fez um gem install -algumagembonitaecharmosaquevaifazertudopragente-, não é? É por aí..

Mas antes da prática, um pouco de teoria para fixar:

RubyGems

A descrição do site oficial diz:

RubyGems is a package manager for the Ruby programming language that provides a standard format for distributing Ruby programs and libraries (in a self-contained format called a “gem”), a tool designed to easily manage the installation of gems, and a server for distributing them.

Utilizando a referência, o RubyGems é um gerenciador de pacotes para ruby que facilita a instalação de gems. Alguns se confundem com a definição e até mesmo com a aplicação dos termos, confundindo um com o outro, mas o RubyGem é, como havia dito, o gerenciador, ou seja, a ferramenta necessária para versionar, instalar, desinstalar, listar , procurar, construir as gems, etc.

E o que são gems?

Bibliotecas, pacotes e até mesmo aplicações em ruby, se assim posso dizer – uma gem é basicamente isso. Porém, a maneira que você vai utilizar essa gem é uma questão de decisão de cada programador de acordo com a decisão de cada projeto.

Teoria, teoria, bla bla bla.

O principal objetivo desse post é aprender como funciona a construção de uma gem simples e como ela pode ser construída. Portanto, não terá nenhum tipo de implementação por agora. Vamos começar com o já subestimado  HelloWorld para o mundo da criação de gems. Depois dessa chuva teórica – e radioativa – abra o seu terminal crie o ambiente ruby para essa gem:

1

rvm gemset create hello_word

rvm gemset create hello_word

1

rvm gemset use hello_word

rvm gemset use hello_word

Se você não sabe ou nunca utilizou o RVM, pode começar lendo aqui e aqui: O RVM irá ajudar bastante na organização dos rubies dos seus projetos.

Criando a estrutura.

A partir daí , passamos para a construção do esqueleto das nossas gems: Alguns preferem via shellzinho [trollface]

1

mkdir -p hello_world/{lib/hello_world,test} 

mkdir -p hello_world/{lib/hello_world,test} 

, outros preferem usar o Jeweler – tanto para estrutura como para o manipulamento – mas eu escolhi o Bundler - a mesma biblioteca que utilizamos no rails para instalar as dependências do Gemfile

Portanto, caso não tiver instalado – verifique com um rvm gem list - utilize o comando gem install bundler  e com a gem já instalada, vamos criar a nossa estrutura assim: $ bundle gem hello_world:

1
2
3
4
5
6
7

create hello_world/Gemfile
create hello_world/Rakefile
create hello_world /.gitignore
create hello_world/hello_world.gemspec
create hello_world/lib/hello_world.rb
create hello_world/lib/hello_world/version.rb
Initializating git repo in /Users/urieljuliatti/git/hello_world

create hello_world/Gemfile
create hello_world/Rakefile
create hello_world /.gitignore
create hello_world/hello_world.gemspec
create hello_world/lib/hello_world.rb
create hello_world/lib/hello_world/version.rb
Initializating git repo in /Users/urieljuliatti/git/hello_world

Modificando o gemspec.

O bundler criou um arquivo .gemspec que possui diversos dados sobre a sua gem recém criada. Algumas partes você precisa modificar, mas falarei em alguns instantes. Obtivemos o seguinte dentro do .gemspec:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# -*- encoding: utf-8 -*-
$:.push File.expand_path("../lib", __FILE__)
require "hello_world/version"
 
Gem::Specification.new do |s|
s.name = "hello_world"
s.version = HelloWorld::VERSION
s.platform = Gem::Platform::RUBY
s.authors = ["Seu nome"]
s.email = ["Seu email"]
s.homepage = "Seu Website"
s.summary = %q{Um resumo.}
s.description = %q{A descrição da sua gem}
 
s.rubyforge_project = "hello_world"
 
s.files = `git ls-files`.split("\n")
s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
s.require_paths = ["lib"]
end

# -*- encoding: utf-8 -*-
$:.push File.expand_path("../lib", __FILE__)
require "hello_world/version"

Gem::Specification.new do |s|
s.name = "hello_world"
s.version = HelloWorld::VERSION
s.platform = Gem::Platform::RUBY
s.authors = ["Seu nome"]
s.email = ["Seu email"]
s.homepage = "Seu Website"
s.summary = %q{Um resumo.}
s.description = %q{A descrição da sua gem}

s.rubyforge_project = "hello_world"

s.files = `git ls-files`.split("\n")
s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
s.require_paths = ["lib"]
end

* Utilizaremos as configurações logo adiante na hora que formos publicar nossas gem.

Versionamento.

Observe que o Bundler criou um /version além de uma constante chamada HelloWorld::VERSION – gerada pelo version.rb dentro de lib/hello_world – para a nossa gem, isto significa que você pode versionar sua gem através dele. Inclusive, esse é um dos bons recursos adquiridos ao tomar uma decisão de criar uma gem . O ideal é você seguir algumas recomendações Semantic Versioning, mas caso deseje uma mais simples, seguiremos com algumas considerações que fiz:

1
2
3
4
5
6
7

# dir: /lib/hello_world/version.rb
 
module HelloWorld
 
VERSION = "0.0.1"
 
end

# dir: /lib/hello_world/version.rb

module HelloWorld

VERSION = "0.0.1"

end

Quando sua gem tiver outros ou novos recursos, é só modificar o número da versão e publicar novamente com o gem build.

Agora vejamos o que foi gerado no diretório lib/, temos um arquivo chamado hello_world  que é o cara que chamamos quando alguém requerer nossa gem. Você pode criar outros arquivos no diretório e chamá-los nessa classe, mas no nosso caso vai ser só o método hello, para demonstração

1
2
3
4
5
6
7
8
9
10
11

# dir: lib/hello_world.rb
 
module HelloWorl
 
def self.hello
 
"Olá mundo!"
 
end
 
end

# dir: lib/hello_world.rb

module HelloWorl

def self.hello

"Olá mundo!"

end

end

Publicando nossa gem.

Bem, agora que você já gerou a estrutura, criou seu arquivo ruby e definiu algum comportamento ( método), vamos então vamos editar nosso gemspec para publicar nossa gem:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# -*- encoding: utf-8 -*-
$:.push File.expand_path("../lib", __FILE__)
require "hello_world/version"
 
Gem::Specification.new do |s|
s.name = "hello_world"
s.version = HelloWorld::VERSION
s.platform = Gem::Platform::RUBY
s.authors = ["Uriel Juliatti"]
s.email = ["uriel.juliatti@giran.com.br"]
s.homepage = ""
s.summary = %q{Primeira gemzinha para aprender como criar a sua própria gem.}
s.description = %q{Essa gem é um demonstrativo do blog do Uriel Juliatti, desenvolvedor web na Giran Soluções e E-commerce.}
 
s.rubyforge_project = "hello_world"
 
s.files = `git ls-files`.split("\n")
s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
s.require_paths = ["lib"]
end

# -*- encoding: utf-8 -*-
$:.push File.expand_path("../lib", __FILE__)
require "hello_world/version"

Gem::Specification.new do |s|
s.name = "hello_world"
s.version = HelloWorld::VERSION
s.platform = Gem::Platform::RUBY
s.authors = ["Uriel Juliatti"]
s.email = ["uriel.juliatti@giran.com.br"]
s.homepage = ""
s.summary = %q{Primeira gemzinha para aprender como criar a sua própria gem.}
s.description = %q{Essa gem é um demonstrativo do blog do Uriel Juliatti, desenvolvedor web na Giran Soluções e E-commerce.}

s.rubyforge_project = "hello_world"

s.files = `git ls-files`.split("\n")
s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
s.require_paths = ["lib"]
end

Agora buildamos a nossa gem:

1
2
3
4
5
6

$ gem build hello_world.gemspec
WARNING: no homepage specified
Successfully built RubyGem
Name: hello_world
Version: 0.0.1
File: hello_world-0.0.1.gem

$ gem build hello_world.gemspec
WARNING: no homepage specified
Successfully built RubyGem
Name: hello_world
Version: 0.0.1
File: hello_world-0.0.1.gem

Esse comando é responsável por gerar um .gem. Inclusive, otimi a homepage, caso contrário ele iria subir o arquivo para o repositório Rubygems.org e deixaria disponível ao público essa gem teste.

Gemfile

1
2
3
4
5
6
7

# -*- encoding: utf-8 -*-
$:.push File.expand_path("../lib", __FILE__)
require "hello_world/version"
 
Gem::Specification.new do |s|
s.add_development_dependency "rspec"
end

# -*- encoding: utf-8 -*-
$:.push File.expand_path("../lib", __FILE__)
require "hello_world/version"

Gem::Specification.new do |s|
s.add_development_dependency "rspec"
end

1
2
3
4
5
6
7
8
9
10

 $ bundle
Fetching source index for http://rubygems.org/
Using diff-lcs (1.1.2)
Using hello_world (0.0.1) from source at /Users/urieljuliatti/Projects/ruby/hello_world
Installing rspec-core (2.3.1)
Installing rspec-expectations (2.3.0)
Installing rspec-mocks (2.3.0)
Installing rspec (2.3.0)
Using bundler (1.0.7)
Your bundle is complete! It was installed into /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p290

 $ bundle
Fetching source index for http://rubygems.org/
Using diff-lcs (1.1.2)
Using hello_world (0.0.1) from source at /Users/urieljuliatti/Projects/ruby/hello_world
Installing rspec-core (2.3.1)
Installing rspec-expectations (2.3.0)
Installing rspec-mocks (2.3.0)
Installing rspec (2.3.0)
Using bundler (1.0.7)
Your bundle is complete! It was installed into /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p290

1
2
3
4
5
6
7
8
9
10
11
12
13

#dir /Rakefile
 
require 'bundler'
 
$ rake -T
 
(in /Users/urieljuliatti/ruby/hello_world)
 
rake build    # Constrói a gem  dentro de um diretório , empacotando-a.
 
rake install  # Constrói e instala a gem no sistema de gems
 
rake release  # Cria uma tag para a versão, constrói a gem e publica lá em Rubygems

#dir /Rakefile

require 'bundler'

$ rake -T

(in /Users/urieljuliatti/ruby/hello_world)

rake build    # Constrói a gem  dentro de um diretório , empacotando-a.

rake install  # Constrói e instala a gem no sistema de gems

rake release  # Cria uma tag para a versão, constrói a gem e publica lá em Rubygems

Public

Geralmente  - e por padrão –  os métodos em ruby são públicos, ao menos que você especifique a visibilidade. Além disso, podem ser chamados de qualquer lugar, pois não há restrição quanto ao seu uso. Mas há uma exceção em cena – o initialize – que é por natureza private. Outras exceções, tais como qualquer método declarado fora da definição da classe – e que podem ser considerados “globais” - também são definidos como private e são métodos específicos de Object.

Private

Um método privado é específico para uma implementação de uma classe e só pode ser chamado por outros métodos de instância de uma classe ou subclasses. Entretanto, métodos privados são implicitamente chamados com self e não podem ser explicitamente chamados em um objeto. Por exemplo, se um método m é private você só pode chamá-lo de forma funcional, como m. É impossível chamar como o.m ou self.m.

Protected

Um método protected é como um método private que só pode ser chamado dentro da implementação da classe ou suas subclasses. A diferença de um método private é que ele pode ser chamado em qualquer instância da classe e não é restrito à chamada implícita do self. Um método protected pode ser usado, por exemplo, em uma situação em que você define um acessor que permita compartilhar os estados dos objetos uns com os outros, mas não permite que os usuários daquela classe tenham acesso aos estados.

Além disso…

Private, protected e public são métodos de instância da classe Module. Em ruby, todas as classes são módulos e dentro da definição da classe, mas fora da definição dos métodos, self refere-se sempre à classe que está sendo definida em questão.

Boas práticas:

Ao declarar métodos private e protected procure alinhá-los ao final da classe

1 2 3 4 5 6 7 8 9 10 11 12

class Test   def initialize(x, y) @x, @y = x, y end   private def backgroud_proc nil end   end

class Test

def initialize(x, y)
@x, @y = x, y
end

private
def backgroud_proc
nil
end

end

Uma outra é que você pode declarar a visibilidade do método sempre após a sua definição, assim:

1 2 3 4 5 6 7 8 9 10 11 12 13

class Foo   def x @x end protected : x   def utility_method nil end private :utility_method   end

class Foo

def x
@x
end
protected : x

def utility_method
nil
end
private :utility_method

end

 

Um outro detalhe importante, mas muito importante  é que a visibilidade public, private e protected aplicam-se apenas aos métodos em Ruby. Variáveis de classe e instância são sempre encapsuladas e definidas como private por padrão, as constantes são sempre públicas – violar essas regras podem custar erros no interpretador. Por fim, não tente definir uma variável como public e acessá-la diretamente, pois como dito, não terá êxito.Uma das formas de fazer esse “acesso direto” é por intermédio dos accessors (attrs) que o ruby oferece – e que facilita muito a nossa vida como desenvolvedor.

Alguns casos são interessantes para se analisar, por exemplo, caso você venha a executar uma fabricação de um objeto (Factory Method) em sua classe, pode vir a necessidade de tornar o método de classe new privado. Para tornar isso possível, utilize o método private_class_method especificando um ou mais nome de métodos – new no nosso caso – como símbolo.

1

private_class_method :new

private_class_method :new

Da mesma forma que você o torna private, você pode torná-lo público com o método public_class_method :new.

Obs: Nenhum método pode ser chamado sem argumentos da mesma forma que o public, protected e private são.

Levando em consideração a flexibilidade da linguagem ruby, suas robustez – que pouco conheço – é importante conhecer  e entender, no entanto, que as capacidades de metaprogramação do Ruby também torna confortável chamar métodos privados e protegidos e até mesmo acessar variáveis ​​de instância encapsuladas.

Dessa forma, se quiséssemos acessar o método privado utility_method declarado anteriormente, poderíamos utilizar o método send, ou até mesmo o método instance_eval para avaliar um bloco no contexto do objeto corrente:

1
2
3
4
5
6
7
8

ruby-1.9.2-p290 :032 > f = Foo.new
=> #<Foo:0x007fba4969d1a0>
ruby-1.9.2-p290 :033 > f.send :utility_method # chamando um método privado!
=> nil
ruby-1.9.2-p290 :034 > f.instance_eval { utility_method } # chamando novamente um método privado!
=> nil
ruby-1.9.2-p290 :035 > f.instance_eval { @x } # lendo uma variável de instância de f
=> nil

ruby-1.9.2-p290 :032 > f = Foo.new
=> #<Foo:0x007fba4969d1a0>
ruby-1.9.2-p290 :033 > f.send :utility_method # chamando um método privado!
=> nil
ruby-1.9.2-p290 :034 > f.instance_eval { utility_method } # chamando novamente um método privado!
=> nil
ruby-1.9.2-p290 :035 > f.instance_eval { @x } # lendo uma variável de instância de f
=> nil

Lindo, não?!

Ainda farei uma cobertura mais abrangente sobre o send e instance_eval quando abordarmos a metaprogramação de uma forma mais investigativa

Então é isso, fechamos mais um episódio com métodos de acesso e acessibilidade no Ruby, o próximo passo será investigar sobre Herança e Subclasses.

Até a próxima!

Antes de mais nada:

Poderia ter deixado para o final, mas vale lembrar que semana que vem acontecerá a RubyConf Brasil, que ocorrerá dia 3 e 4 de novembro em São Paulo. Nem é uma questão de puro merchanda, mas vale a pena mesmo comparecer em um evento tão importante como esse. Além de encontrar profissionais da área e palestras de qualidade (feitas também por profissionais da área), tem toda a questão de fortalecer e acompanhar o crescimento da linguagem no Brasil. Veja o cast http://rubyconf2011.akitaonrails.com/br/speakers.html e me diga se você não se assustou com tamanha qualidade. (Detalhe pra quem curte: Se liga na camisa do Nick Sutterer hehehe).

Pois é, muita coisa boa. As inscrições encerraram, mas vale a dica para o RubyConf do ano que vem. Provavelmente trarei um post aqui com a cobertura parcial do evento.

Link do evento: http://rubyconf2011.akitaonrails.com/

Rollback.

Bem, agora vamos voltar com o ruby e falar um pouco sobre Variáveis de Classe.

O que são Variáveis de Classe?

Elas são visíveis e compartilhadas para os métodos de classe e os métodos de instância de uma classe e até mesmo pela definição da própria classe, em suma, com ela é possível que todos os objetos a compartilhem. Se você lembrar da programação tradicional, ela funciona como se fosse uma variável global. Assim como as variáveis de instância, as variáveis de classe são encapsuladas; podem ser usadas na implementação de uma classe, porém não permitem acesso direto. Em ruby, elas possuem a sintaxe marcada pelo @@.

Uma maneira elegante de mostrar a sua utilização seria em um caso onde contabilizaríamos o número de objetos de uma classe que foram criados, por exemplo.

1
2
3
4
5
6
7
8
9
10
11
12
13

class Test
 
   @@n = 0
 
   def initialize
       @@n += 1
   end
 
   def self.report
       puts "Number of objects created: #@@n"
   end
 
end

class Test

   @@n = 0

   def initialize
       @@n += 1
   end

   def self.report
       puts "Number of objects created: #@@n"
   end

end

Com o método de classe report, conseguimos obter um retorno com o número de objetos já criados:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ruby-1.9.2-p136 :018 > t = Test.new
 => #
 
ruby-1.9.2-p136 :019 > Test.report
Number of objects created: 1
 => nil
 
ruby-1.9.2-p136 :020 > Test.report
Number of objects created: 1
 => nil
 
ruby-1.9.2-p136 :022 > t = Test.new
 => #
 
ruby-1.9.2-p136 :023 > Test.report
Number of objects created: 2
 => nil

ruby-1.9.2-p136 :018 > t = Test.new
 => #

ruby-1.9.2-p136 :019 > Test.report
Number of objects created: 1
 => nil

ruby-1.9.2-p136 :020 > Test.report
Number of objects created: 1
 => nil

ruby-1.9.2-p136 :022 > t = Test.new
 => #

ruby-1.9.2-p136 :023 > Test.report
Number of objects created: 2
 => nil

Variáveis de Instância de uma Classe

Classes são objetos e podem ter variáveis de instância assim como os objetos podem ter. As variáveis de instância de uma classe – as vezes chamadas apenas de variáveis de instância de classe - não são a mesma coisa que variáveis de instância. Mas elas são parecidas o suficiente epodem também ser usadas ao invés das variáveis de classe.

Uma variável de classe utilizada dentro de uma definição de classe e fora de um método de instância é uma variável de instância de uma classe.  Assim como variáveis ​​de classe, variáveis ​​de instância de classe são associadas com a classe do que com qualquer instância específica da classe.

A desvantagem de usá-las é que elas não podem ser usadas dentro de métodos de instância como as variáveis de classe usam. Além dessa desvantagem, existe uma considerável possibilidade de confundir as variáveis de instância de classe com as variáveis de instância simples.

Para ficar bem claro: As variáveis de instância são criadas quando você instancia a Classe e as variáveis de instância de classe são injetadas em tempo de execução, partindo do princípio de que o objeto já foi instanciado.

Da mesma forma que as variáveis de instância, podemos utilizar attr, attr_reader e attr_accessor para criar métodos de acesso para elas. A única coisa que deve ser levada em consideração é que, para chamar esses métodos utilizados em metaprogramação no contexto certo.

1
2
3

class << self
      attr_accessor : n, : x, : y
end

class << self
      attr_accessor : n, : x, : y
end

Com esses acessores definidos, podemos fazer referências aos dados utilizados em Ponto.x, Ponto.y, Ponto.n

Então rapazeada, ficamos nessa por aqui. Vou rumo a RubyConf que com certeza trará muito esclarecimento,
conhecimento e novas experiências.

Abraços!

Referências Externas:

http://railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/

http://sporkmonger.com/2007/2/19/instance-variables-class-variables-and-inheritance-in-ruby

http://www.oreillynet.com/ruby/blog/2007/01/nubygems_dont_use_class_variab_1.html

Bem, o objetivo desse post não é explicar em detalhes o que é o rake, mas sim em como customizá-lo. Portanto, de forma resumida, ele é nada mais do que uma gem que quando instalada utiliza-se do executável ‘rake’ para demandar suas tarefas. A idéia é de que funcionasse como o ‘make’ do Unix, ou seja, um Ruby Make, se assim posso dizer hehe. Contudo, entre piadinhas ruins a parte, o rake é responsável por executar tarefas em sua aplicação.

O rails precisa que você executa o rake a partir da raiz do projeto para que ele acesse o seu RakeFile. Só por uma questão de investigação, abra o seu RakeFile:

1
2
3
4

require File.expand_path('../config/application', __FILE__)
require 'rake'
 
Project::Application.load_tasks</pre>

require File.expand_path('../config/application', __FILE__)
require 'rake'

Project::Application.load_tasks</pre>

A partir daí, ele prepara o ‘ambiente’ para todas as tarefas que existirem, customizadas ou não.

Customizando.

O acesso que você possui para customizar tarefas é em /lib/tasks. Neste exemplo, vou mostrar como configurar uma tarefa de seed específico para um rake db:seed, veja o resultado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# libs/tasks/
namespace :db do
   # poderia ser qualquer outra coisa que seguisse os padrões do :db
   namespace :seed do
      # qualquer coisa.
      task :galeria => :environment do
         #exemplo desabilitando uma galeria
         galeria = Attribute.find_by_name('Galeria')
         if galeria
            galeria.update_attributes(:code => 1, :name => "Galeria", :installed => 0)
            galeria.save
         end
     end
  end
end

# libs/tasks/
namespace :db do
   # poderia ser qualquer outra coisa que seguisse os padrões do :db
   namespace :seed do
      # qualquer coisa.
      task :galeria => :environment do
         #exemplo desabilitando uma galeria
         galeria = Attribute.find_by_name('Galeria')
         if galeria
            galeria.update_attributes(:code => 1, :name => "Galeria", :installed => 0)
            galeria.save
         end
     end
  end
end

Ao executar rake db:seed:galeria, vou ter minha galeria desabilitada.

É isso aí e até o próximo!

Referências:

http://databasically.com/2008/08/03/rake-list-tasks/ | Lista com várias tasks para :db

http://www.tutorialspoint.com/ruby-on-rails/rails-and-rake.htm

http://akitaonrails.com/2009/02/16/automatizando-tarefas-com-ruby-e-rake

Pois é, vamos aqui seguindo mais um post para contribuir para essa longa e maravilhosa jornada que estou percorrendo com o ruby.

Resolvi ir direto para um tema que estou tendo bastante curiosidade no momento, que é sobre Classes e Módulos com ruby, especialmente os módulos.

Começarei com as Classes, cuja abordagem é vasta, podendo ser dividida em várias etapas. É bem capaz que eu resuma muita coisa, dando ênfase apenas as partes relevantes, mas sempre deixando algumas referências para acrescentar e talvez divida esse post em séries de posts, para facilitar a divisão dos tópicos.

Antes de tudo.

Como muitos de nós sabemos, Ruby  é uma linguagem puramente Orientada a Objetos, cada valor é (ou ao menos se comporta) como um objeto. Todo objeto é uma instância de uma classe. E uma classe define uma série de métodos que respondem a um objeto. Por convenção de arquitetura de software, uma classe pode extender ou ser uma subclasse de outras classes e herdar ou sobrescrever métodos de suas superclasses. Em Ruby, as classes também podem ter métodos herdados de módulos.

Os objetos são estritamente encapsulados: Os estados só podem ser acessados por seus métodos já definidos. As variáveis de instância manipuladas por esses métodos não podem ser acessadas diretamente por fora do objeto. É possível gerar getters e setters, acessando diretamente o estado do objeto. Esses acessores são conhecidos como atributos são diferentes das variáveis de instância. A visibilidade dos métodos de uma classe podem ser definidas como “public”, “private” ou “protected” que afetam drásticamente na forma que eles são chamados.

Ao contrário do que se pensa sobre as restrições geradas pelo encapsulamento de um estado do objeto, as classes em Ruby são bastante abertas. Qualquer programa em ruby pode adicionar métodos para classes já existentes e até mesmo métodos singleton para objetos específicos. É um conceito bem interessante, pois ao fazer:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Test
 
   def user(nome)
 
       nome ||= "João Padrão"
 
   end
 
end
 
# abrindo a mesma classe e editando-a novamente
 
def Test
 
    def user(nome, cpf)
 
        nome ||= "Pedro Padrão"
 
        cpf ||= "106.778.900-90"
 
    end
 
end

class Test

   def user(nome)

       nome ||= "João Padrão"

   end

end

# abrindo a mesma classe e editando-a novamente

def Test

    def user(nome, cpf)

        nome ||= "Pedro Padrão"

        cpf ||= "106.778.900-90"

    end

end

O que vamos fazer inicialmente é definir uma classe e seus métodos. Muita coisa aqui vai ser retomada posteriormente, com uma abordagem mais avançada

Definindo uma classe.

Baby Steps, é um conceito que meu amigo @m3nd3s sempre aconselha. Seguindo esse conselho, vamos dar início a esse tópico definindo uma classe bem boba, mas que aborda um aprendizado conciso.

O que precisamos para criar uma classe? Definí-la. É tudo muito simples:

1
2
3

class Ponto
 
end

class Ponto

end

Com a palavra chave “class” definimos uma classe, seguindo pelo end, que fecha seu escopo. Não sei vocês observaram, a classe foi nomeada com a inicial maiúscula, é uma regra do Ruby, obrigatória por sinal. O nome da constante e o nome da classe são os mesmos, você verá isso posteriormente com mais detalhes.

Instanciando.

Mesmo se não colocarmos nada na classe Ponto, podemos instanciá-la:

1
2

ruby-1.9.2-p290 :005 > p = Ponto.new
=> #<Ponto:0x00000106b99c70>

ruby-1.9.2-p290 :005 > p = Ponto.new
=> #<Ponto:0x00000106b99c70>

A constante Ponto mantêm em um objeto o que representa a nossa classe. Todos os objetos possuem um método chamado new que é responsável por criar uma nova instância. Não há muita coisa interessante a fazer com esse objeto que criamos, apenas verificar algo do tipo:

1
2
3
4
5

ruby-1.9.2-p290 :006 > p.class
=> Ponto
 
ruby-1.9.2-p290 :008 > p.is_a?Ponto
=> true

ruby-1.9.2-p290 :006 > p.class
=> Ponto

ruby-1.9.2-p290 :008 > p.is_a?Ponto
=> true

Inicializando.

Se você veio de outras linguagens orientadas a objeto, certamente deve conhecer o termo “construtor”, é exatamente isso que
o initialize faz.

1
2
3
4
5
6
7

class Ponto
 
   def initialize(x,y)
       @x, @y = x,y
   end
 
end

class Ponto

   def initialize(x,y)
       @x, @y = x,y
   end

end

Com esse método definido, podemos criar outros ponteiros e ver o seu retorno.

1
2
3
4
5

ruby-1.9.2-p290 :008 > p = Ponto.new(1,10)
 => #<Ponto:0x00000105dd6fc0 @x=1, @y=10>
 
ruby-1.9.2-p290 :009 > p
 => #<Ponto:0x00000105dd6fc0 @x=1, @y=10>

ruby-1.9.2-p290 :008 > p = Ponto.new(1,10)
 => #<Ponto:0x00000105dd6fc0 @x=1, @y=10>

ruby-1.9.2-p290 :009 > p
 => #<Ponto:0x00000105dd6fc0 @x=1, @y=10>

Repare bem nas variáveis de instância x e y, que ja foram inicializadas para o objeto corrente com o valor de 1 e 10 para x e y, respectivamente.
Acessores e Atributos

Como falei anteriormente, a classe Ponto utiliza duas variáveis de instância, contudo, o valor dessas variáveis estão acessiveis apenas para outros métodos de instância. Isto significa se quisermos que outros objetos da classe queiram utilizar métodos para acessar o valor de X e Y, teremos que fornecer métodos acessores que retornariam os valores dessas variáveis.

Ao pé da letra, para quem vem de outras linguagens Orientadas a Objeto, faríamos assim:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Ponto
 
   def initialize(x,y)
       @x, @y = x,y
   end
 
   def x
      @x
   end
 
   def y
      @y
   end
 
end

class Ponto

   def initialize(x,y)
       @x, @y = x,y
   end

   def x
      @x
   end

   def y
      @y
   end

end

Uma vez definindo esses métodos, poderíamos fazer isso:

1
2
3
4
5

ruby-1.9.2-p290 :023 > p = Ponto.new(1,2)
 => #<Ponto:0x00000105db3700 @x=1, @y=2>
 
ruby-1.9.2-p290 :024 > q = Ponto.new(p.x*2, p.y*3)
 => #<Ponto:0x00000105dab870 @x=2, @y=6>

ruby-1.9.2-p290 :023 > p = Ponto.new(1,2)
 => #<Ponto:0x00000105db3700 @x=1, @y=2>

ruby-1.9.2-p290 :024 > q = Ponto.new(p.x*2, p.y*3)
 => #<Ponto:0x00000105dab870 @x=2, @y=6>

Agora, para fazermos um setter, faríamos algo do tipo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Ponto
 
   def initialize(x,y)
       @x, @y = x,y
   end
 
   def x
      @x
   end
 
   def y
      @y
   end
 
   def x=(value)
       @x = value
   end
 
   def y=(value)
       @y = value
   end
 
end

class Ponto

   def initialize(x,y)
       @x, @y = x,y
   end

   def x
      @x
   end

   def y
      @y
   end

   def x=(value)
       @x = value
   end

   def y=(value)
       @y = value
   end

end

Dessa forma, modificaríamos o valor da variável de instância do objeto corrente da seguinte jeito:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

ruby-1.9.2-p290 :045 > p = Ponto.new(1,1)
 => #<Ponto:0x00000105d790f0 @x=1, @y=1>
 
ruby-1.9.2-p290 :046 > p.x = 0
 => 0
 
ruby-1.9.2-p290 :047 > p
 => #<Ponto:0x00000105d790f0 @x=0, @y=1>
 
ruby-1.9.2-p290 :048 > p.y = 50
 => 50
 
ruby-1.9.2-p290 :049 > p
 => #<Ponto:0x00000105d790f0 @x=0, @y=50>

ruby-1.9.2-p290 :045 > p = Ponto.new(1,1)
 => #<Ponto:0x00000105d790f0 @x=1, @y=1>

ruby-1.9.2-p290 :046 > p.x = 0
 => 0

ruby-1.9.2-p290 :047 > p
 => #<Ponto:0x00000105d790f0 @x=0, @y=1>

ruby-1.9.2-p290 :048 > p.y = 50
 => 50

ruby-1.9.2-p290 :049 > p
 => #<Ponto:0x00000105d790f0 @x=0, @y=50>

Porém, com ruby podemos simplificar a nossa vida, muitas vezes com apenas uma linha. Nesse exemplo, seguiremos o legado rubyway e faremos os getters e setters em apenas duas linhas:

1
2
3
4
5

class Ponto
 
   attr_accessor : x, :y
 
end

class Ponto

   attr_accessor : x, :y

end

Faça a mesma coisa agora no terminal para você ver o retorno:

1
2
3
4
5
6
7
8

ruby-1.9.2-p290 :065 > p = Ponto.new(10,10)
 => #<Ponto:0x00000105d1a528 @x=10, @y=10>
 
ruby-1.9.2-p290 :066 > p.x = 20
 => 20
 
ruby-1.9.2-p290 :067 > p
 => #<Ponto:0x00000105d1a528 @x=20, @y=10>

ruby-1.9.2-p290 :065 > p = Ponto.new(10,10)
 => #<Ponto:0x00000105d1a528 @x=10, @y=10>

ruby-1.9.2-p290 :066 > p.x = 20
 => 20

ruby-1.9.2-p290 :067 > p
 => #<Ponto:0x00000105d1a528 @x=20, @y=10>

Existem os métodos attr_writer (setter), attr_reader (getter) e o que utilizamos, o attr_accessor (getter e setter), eles são responsáveis por criarem métodos de instância para nós

Esse é um exemplo clássico de metaprogramação, e a habilidade de fazer isso é um dos maiores recursos que o ruby oferece.

Métodos de Classe.

Para quem já conhece a Orientação a Objetos, sabe que um método de classe pode ser acessado apenas pela própria classe seja lá onde ele for chamado. Isto é, no exemplo que estamos seguindo, o método de classe que vamos criar agora não é um método de instância que seria chamado em um objeto Ponto.

A chamada para o método de classe seria algo como:

1

total = Ponto.soma(p1, p2,p3)

total = Ponto.soma(p1, p2,p3)

1
2
3
4
5
6
7
8
9
10
11

class Ponto
 
   attr_reader : x, :y
 
   def self.soma(*pontos)
       x = y = 0
       pontos.each {|p| x += p.x; y += p.y}
       Ponto.new(x,y)
   end
 
end

class Ponto

   attr_reader : x, :y

   def self.soma(*pontos)
       x = y = 0
       pontos.each {|p| x += p.x; y += p.y}
       Ponto.new(x,y)
   end

end

Dessa forma, estaremos acessando a soma de todos os x e y de cada ponto através de um método de classe

Constantes.

Várias classes podem ser beneficiadas por uma associação e definição de algumas constantes, eis um exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Ponto
 
def initialize(x,y)
 
    @x, @y = x,y
 
end
 
ORIGEM = Ponto.new(0,0)
 
COORD_X = Ponto.new(1,0)
 
COORD_Y = Ponto.new(0,1)
 
[...]
 
end

class Ponto

def initialize(x,y)

    @x, @y = x,y

end

ORIGEM = Ponto.new(0,0)

COORD_X = Ponto.new(1,0)

COORD_Y = Ponto.new(0,1)

[...]

end

Uma vez dentro da classe, as constantes podem ser acessadas pelos nomes, diretamente. Caso estejam fora, para serem acessadas, devem estar acompanhada no nome da classe, como no exemplo:

1

Ponto::COORD_X + PONTO::CORD_Y

Ponto::COORD_X + PONTO::CORD_Y

Você pode inicializar até mesmo fora da classe:

1
2

ruby-1.9.2-p136 :206 > Ponto::COORD_X = Ponto.new(2,0)
 => #<Ponto:0x00000103bb2728 @x=2, @y=0>

ruby-1.9.2-p136 :206 > Ponto::COORD_X = Ponto.new(2,0)
 => #<Ponto:0x00000103bb2728 @x=2, @y=0>

O tópico é enorme, portanto, vou extendê-lo em outros posts. Para o próximo post trarei tópicos que abordam Variáveis de Classe, Variáveis de Instância e Visibilidade.

Referências:

http://www.ruby-doc.org/docs/ProgrammingRuby/html/classes.html

http://www.devarticles.com/c/a/Ruby-on-Rails/Ruby-Classes-and-Objects/

http://blog.bluesoft.com.br/ruby-classes-e-objetos/

A necessidade surgiu quando tive a necessidade de criar um campo/atributo booleano para um modelo já existente.

Presume-se que você já tenha um modelo, no meu caso é o User, que possui apenas um atributo “name” e “email.

O Rails fornece um recurso interessante: Migrations, que vai te ajudar bastante a organizar sua base de dados e todo o fluxo possível.

Para criar uma migration para um model existente você fará assim:

1

rails g migration AddHiddenToUser hidden:boolean

rails g migration AddHiddenToUser hidden:boolean

Onde o hidden será o campo novo para o modelo User que já existe. O console trará o seguinte:

1
2

invoke  active_record
create    db/migrate/20111021182503_add_hidden_to_user.rb

invoke  active_record
create    db/migrate/20111021182503_add_hidden_to_user.rb

Ele chama o Active Record e cria um arquivo baseado na linha que você digitou. Aproveite e abra a sua migration gerada, logo você obterá:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class AddHiddenToUser < ActiveRecord::Migration
 
def self.up
 
add_column :users, :hidden, :boolean
 
end
 
def self.down
 
remove_column :users, :hidden
 
end
 
end

class AddHiddenToUser < ActiveRecord::Migration

def self.up

add_column :users, :hidden, :boolean

end

def self.down

remove_column :users, :hidden

end

end

Lindo! O Rails reconheceu que você quer adicionar um atributo do tipo boolean para uma tabela Users (add_column :users, :hidden, :boolean)

Até agora o rails fez todo o esqueleto, porém nada ainda funciona. Para isso funcionar, você vai ter que rodar um rake db:migrate, onde o rails executa uma função que adiciona literalmente o atributo “hidden” a sua tabela Users.

Veja o log após a execução do comando:

1
2
3
4

<pre>==  AddHiddenToUser: migrating ================================================
-- add_column(:users, :hidden, :boolean)
   -> 0.0081s
==  AddHiddenToUser: migrated (0.0082s) =======================================</pre>

<pre>==  AddHiddenToUser: migrating ================================================
-- add_column(:users, :hidden, :boolean)
   -> 0.0081s
==  AddHiddenToUser: migrated (0.0082s) =======================================</pre>

Lindezidade total, hein?

Para finalizar, basta adicionar o field na view:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<pre><%= form_for(@user) do |f| %>
  <%= render "shared/error_messages", :target => @user %>
 
  <div class="field">
    <%= f.label :name %><%= mark_required(@user, :name) %><br />
    <%= f.text_field :name %>
  </div>
  <div class="field">
    <%= f.label :email %><%= mark_required(@user, :email) %><br />
    <%= f.text_field :email %>
  </div>
 <div class="field"></strong>
     <%= f.label :hidden %><br />
     <%= f.check_box :hidden %>
 </div>
  <div class="actions">
    <%= f.submit %>
  </div>
<% end %>

<pre><%= form_for(@user) do |f| %>
  <%= render "shared/error_messages", :target => @user %>

  <div class="field">
    <%= f.label :name %><%= mark_required(@user, :name) %><br />
    <%= f.text_field :name %>
  </div>
  <div class="field">
    <%= f.label :email %><%= mark_required(@user, :email) %><br />
    <%= f.text_field :email %>
  </div>
 <div class="field"></strong>
     <%= f.label :hidden %><br />
     <%= f.check_box :hidden %>
 </div>
  <div class="actions">
    <%= f.submit %>
  </div>
<% end %>

Antes de concluir, um detalhe importante que percebi ao implementar essa funcionalidade é que o Rails fornece funcionalidades bacanas ao acrescentar uma migration dessa forma. Abra o seu console e teste da seguinte forma:

1
2
3
4

ruby-1.9.2-p136 :004 > user = User.first
 => #<User id: 1, name: "Uriel", email: "uriel.juliattivalle@gmail.com", created_at: "2011-10-21 18:39:36", updated_at: "2011-10-21 18:39:36", hidden: true>
ruby-1.9.2-p136 :005 > user.hidden?
 => true

ruby-1.9.2-p136 :004 > user = User.first
 => #<User id: 1, name: "Uriel", email: "uriel.juliattivalle@gmail.com", created_at: "2011-10-21 18:39:36", updated_at: "2011-10-21 18:39:36", hidden: true>
ruby-1.9.2-p136 :005 > user.hidden?
 => true

Uma vez que seu atributo é do tipo Boolean, o rails fornece um helper method chamado “hidden?” que retorna true ou false. Muito útil, uma vez que outras situações teríamos que fazê-lo na mão, apesar de simples tomaria um certo tempo.

Semana que vem tem RubyConf2011! Ainda dá tempo de se cadastrar http://rubyconf2011.akitaonrails.com/en/

É isso aí rapazeada, vamo que vamo!

Desde quando comecei a minha jornada no mundo do desenvolvimento na Giran (@giran_br), tenho tido contato com inúmeras novidades, entre elas:

• A prática do versionar software (Git).
• Documentação de Software.
• Metodologias Ágeis.
• Uso freqüente do terminal (o/).
•  Simpatia pelo Macbook (não consigo me imaginar utilizando outra máquina ou qualquer outro SO que não seja baseado no kernel Unix).
• Testes (Um alô para Flávia Missi (@flaviamissi) e por todo o legado de preocupações com testes que ela deixou enquanto estava no time).
• Participações em coding dojos.
• Pão Caseiro (via @m3nd3s).
• A comunicação diária usando a língua inglesa por conta do nosso parceiro Petros (Grego Belezidade!) me deixa muito motivado.
• Essa equipe é fo**!
• Existe empresa que se esforça para cuidar do seu funcionário, sem balelas ou merchanda gratuito.

São inúmeras, eu não listei todas. Entretanto, todas elas têm mudado aos poucos minha visão como desenvolvedor, profissional e sim, é possível, como ser humano.

O Dojo.

Digamos que o conceito de coding dojo seja, além de ser um desafio para programadores, é também se divertir, e, “através de uma metodologia pragmática, melhorar suas habilidades de programação e de trabalho em grupo”.

Pois é, pode aparentar irrisório o que vou falar, mas nem só de vitórias vivemos.. E as minhas últimas experiências com dojo têm sido frustrantes quanto ao meu desempenho pessoal, mas o dojo em si está sendo uma experiência sensacional e desafiadora.

Falando sobre a pseudo frustração, se você conhece alguém que nunca tenha tido um deslize, com certeza essa pessoa não é humana. Erros são inerentes à natureza (e não só a nossa, acredite), a única diferença é de como enfrentamos.

Só fui dar conta ultimamente , pois estava codando de maneira afobada e ansiosa por resultados instantâneos. E a minha ficha caiu de verdade quando eu congelei em um dojo com amigos na empresa. Eu poderia descrever inúmeros fatores que contribuíram para esse infortúnio, falar que sou “iniciante” e afobado ao mesmo tempo contaria como 80% da causa (haha ), certo? Errado, há motivos para se importar por tão pouco!? Conclusão que só cheguei com ajuda de amigos na empresa e pessoas mais próximas fora dela.

É óbvio que nesse post não vou postar sobre as soluções que vou tomar daqui para frente, pois estou buscando-as, mas ao contrário do que até mesmo eu esperava, ao me deparar com uma derrapada dessas tive uma vontade ainda maior de aprender mais e mais.

O Código e o Caminho do Guerreiro.

Depois dessas lamúrias sobre o dojo.. Um desafio eu enfrentar escolhi (Ahhh Yoda!!).

Acostumado a acompanhar os livros e viciado a não praticar com exemplos mais , digamos assim, “relevantes”, resolvi tomar uma iniciativa mais aprimorada (é claro que vai depender do seu ponto de vista e experiência).

Escolhi um problema de um dojo (http://dojopuzzles.com/problemas/exibe/jokenpo/) como referência e resolvi praticá-lo “sozinho” na hora do meu almoço, sem seguir as regras do dojo.

OBS: Sozinho?! Oi?! Seria uma blasfêmia dizer que fiz um dojo sozinho, não faz sentido, mas vocês entenderam!

Para acessar o repositório git com a resolução: http://www.github.com/urieljuliatti/ruby-challenges

Todo e qualquer feedback será bem vindo! Pode descer a lenha também, eu aceitarei o desafio

Inicialmente, o ruby é uma linguagem quase toda orientada a objetos, eu disse “quase” porque existem uns que dizem que não, outros dizem que sim, a discussão é bem longa. Todavia, em ruby todos os valores são objetos e não há uma distinção entre valores primitivos e objetos, como acontece em outras linguagens. Todos os objetos herdam da classe Object e compartilham entre si métodos definidos por essa classe.

Não.
Não vou ensinar orientação a objetos. Para ler esse artigo, presume-se que já entenda os conceitos básicos da orientação a objetos.

Bora lá?

Referências a objetos.
A classe Object define dois métodos muito parecidos para copiar objetos.
Quando trabalhamos com objetos em ruby, estamos nada mais nada a menos do que trabalhando com a sua referência, não o objeto em si.

Nada melhor do que um código para visualizar o que acontece:

1
2
3
4
5
6
7
8
9
10
11
12
13

ruby-1.9.2-p136 :090 > s = "Ruby"
 => "Ruby"
ruby-1.9.2-p136 :091 > t = s
 => "Ruby"
ruby-1.9.2-p136 :092 > t[-1] = ""
 => ""
ruby-1.9.2-p136 :093 > print s
Rub => nil
ruby-1.9.2-p136 :094 > t = "Java"
 => "Java"
ruby-1.9.2-p136 :095 > print s,t
RubJava => nil
ruby-1.9.2-p136 :096 >

ruby-1.9.2-p136 :090 > s = "Ruby"
 => "Ruby"
ruby-1.9.2-p136 :091 > t = s
 => "Ruby"
ruby-1.9.2-p136 :092 > t[-1] = ""
 => ""
ruby-1.9.2-p136 :093 > print s
Rub => nil
ruby-1.9.2-p136 :094 > t = "Java"
 => "Java"
ruby-1.9.2-p136 :095 > print s,t
RubJava => nil
ruby-1.9.2-p136 :096 >

Na ordem, criamos um objeto do tipo String e guardamos uma referência para ele em s. Em seguida, copiamos a mesma referência para o t, onde s e t agora estão fazendo uma referência para o mesmo objeto.
Na terceira linha nós modificamos o objeto em que a referência está guardada em t e mandamos printá-lo na linha seguida, retornando modificado.
Na penúltima linha, referenciamos para um novo objeto (s), diferente de t.
E por fim, na última linha printamos os dois objetos.

Nota interessante: Engraçado é que se você está acostumado com C ou C++, fatalmente pensará que estamos lidando diretamente com ponteiros. Ô, ô! Engana-se quem pensa, pois ruby não permite você usar ponteiros para manipulação , aritimética e desreferenciação, como alguns já devem ter visto. As referências em ruby são implícitas na implementação, completamante abstraídas.

Quando passamos um objeto para um método uma referência ao objeto é passada, não o objeto em si e nem mesmo uma referência para a referência. A maneira mais segura de dizer é que os argumentos são passados por valor.

Tempo de vida do objeto.
Para dar início ao ciclo de vida de um objeto em Ruby necessitamos de um método chamado “new” existente na classe Class. Ele aloca memória para o novo objeto e então inicializa seu estado como vazio ao chamar um outro método “initialize”. Como padrão, boa parte das classes possuem um inicializador para executar qualquer tipo de inicialização (caso necessário) para as instâncias.

Os objetos em ruby não precisam ser explicitamente desalocados, assim como é feito em C ou C++ onde precisamos executar um free() para desalocar. O ruby usa uma técnica já conhecida, a de garbage collection, para destruir automaticamente objetos que não estão sendo necessários. Um objeto se torna candidato do garbage quando ele está “inalcançável” , isto é, quando não existem referências para aquele objeto a não ser de outros objetos “inalcançáveis”.

Obs1: Aqueles que desejam um aprofundamento sobre o assunto, existem alguns artigos na Ruby Inside sobre o GC, tal como esse aqui, por exemplo.

Obs2: Apesar de usar o GC , isto não significa que problemas com alocação de memória não existam em Ruby.

A classe Object e o tipo Object.

Há várias maneiras de determinar uma classe de um objeto em Ruby. A forma mais simplista é acrescentar um .class no objeto para o interpretador devolver a classe.
Ex:

1
2
3
4

ruby-1.9.2-p136 :022 > objeto = "teste"
 => "teste"
ruby-1.9.2-p136 :023 > objeto.class
 => String

ruby-1.9.2-p136 :022 > objeto = "teste"
 => "teste"
ruby-1.9.2-p136 :023 > objeto.class
 => String

A não ser que você queira saber a hierarquia de um objeto, você pode navegar pelas superclasses, assim:

1
2
3
4
5
6

ruby-1.9.2-p136 :024 > o.class.superclass
 => Object
ruby-1.9.2-p136 :025 > o.class.superclass.superclass
 => BasicObject
ruby-1.9.2-p136 :026 > o.class.superclass.superclass.superclass
 => nil

ruby-1.9.2-p136 :024 > o.class.superclass
 => Object
ruby-1.9.2-p136 :025 > o.class.superclass.superclass
 => BasicObject
ruby-1.9.2-p136 :026 > o.class.superclass.superclass.superclass
 => nil

Obs: No 1.9, a classe Object não é a classe raiz dos objetos, mas sim a BasicObject (Veja mais na documentação).

Há várias maneiras de saber se tal objeto pertence a uma determinada classe, desde comparativos diretos (objeto.class == String) até o mais elegante de todos, o objeto.instance_of?String.

Geralmente, quando testamos uma classe de um objeto, também desejamos saber se o objeto é uma instância de alguma subclasse. Para fazer essa verificação, usa-se o is_a? ou kind_of?. Ex:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ruby-1.9.2-p136 :027 > object = 1
 => 1
ruby-1.9.2-p136 :028 > object.instance_of?Fixnum
 => true
ruby-1.9.2-p136 :029 > object.instance_of?Numeric
 => false
ruby-1.9.2-p136 :030 > object.is_a?Fixnum
 => true
ruby-1.9.2-p136 :031 > object.is_a?Integer
 => true
ruby-1.9.2-p136 :032 > object.is_a?Numeric
 => true
ruby-1.9.2-p136 :033 > object.is_a?Comparable
 => true
ruby-1.9.2-p136 :034 > object.is_a?Object
 => true

ruby-1.9.2-p136 :027 > object = 1
 => 1
ruby-1.9.2-p136 :028 > object.instance_of?Fixnum
 => true
ruby-1.9.2-p136 :029 > object.instance_of?Numeric
 => false
ruby-1.9.2-p136 :030 > object.is_a?Fixnum
 => true
ruby-1.9.2-p136 :031 > object.is_a?Integer
 => true
ruby-1.9.2-p136 :032 > object.is_a?Numeric
 => true
ruby-1.9.2-p136 :033 > object.is_a?Comparable
 => true
ruby-1.9.2-p136 :034 > object.is_a?Object
 => true

Perceba que na situação em que object.instance_of?Numeric retorna falso, ele não chega a herança. Porém, se você faz o comparativo com object.is_a?Numeric, ele retorna true.

Cada objeto tem uma classe bem definida em Ruby, tal classe nunca muda durante o ciclo de vida de um objeto. Porém, um tipo de objeto é mais flexível, pois está relacionado a sua classe, mas a classe é apenas uma parte de um tipo de objeto. Quando falo sobre tipos de objetos, estou me referenciando a um conjunto de comportamentos que caracterizam o objeto.

Algo importante para lembrar ao programar ruby é o fato de que não se dá tanta importância as classes de um objeto, queremos apenas saber se podemos chamar um método dela. Considere,por exemplo, o operador “<<”. Arrays, strings, arquivos e outras classes responsáveis por entrada/saída definem genericamente esse operador como um anexador. Para esclarecer, não damos importância aos argumentos passados para a classe, sabemos que pode ser anexado usando o operador <<. Até podemos testar se a classe responde a esse operador utilizando o respond_to?

1
2
3

ruby-1.9.2-p136 :004 > object = "Teste"
 => "Teste"
ruby-1.9.2-p136 :005 > object.respond_to? :"< true

ruby-1.9.2-p136 :004 > object = "Teste"
 => "Teste"
ruby-1.9.2-p136 :005 > object.respond_to? :"< true

Aí sim, estamos testando apenas se o operador pode ser chamado na classe String, não os parâmetros para o método.

Semelhanças entre os objetos
O ruby fornece várias maneiras de comparar objetos pela sua semelhança e é importante saber como alguns métodos funcionam.

O método equal?

O método equal? (Fornecido pela classe Object) é responsável por verificar se dois valores referem-se exatamente ao mesmo objeto.

1
2
3
4
5
6
7
8

ruby-1.9.2-p136 :006 > a = "Ruby"
 => "Ruby"
ruby-1.9.2-p136 :007 > b = c = "Ruby"
 => "Ruby"
ruby-1.9.2-p136 :008 > a.equal?(b)
 => false
ruby-1.9.2-p136 :009 > b.equal?(c)
 => true

ruby-1.9.2-p136 :006 > a = "Ruby"
 => "Ruby"
ruby-1.9.2-p136 :007 > b = c = "Ruby"
 => "Ruby"
ruby-1.9.2-p136 :008 > a.equal?(b)
 => false
ruby-1.9.2-p136 :009 > b.equal?(c)
 => true

a e b são objetos diferentes, mas b e c possuem referências para o mesmo objeto.

Outra maneira para realizar a mesma operação é verificar se o object_id é igual.

1
2
3
4

ruby-1.9.2-p136 :014 > a.object_id == b.object_id
 => false
ruby-1.9.2-p136 :015 > b.object_id == c.object_id
 => true

ruby-1.9.2-p136 :014 > a.object_id == b.object_id
 => false
ruby-1.9.2-p136 :015 > b.object_id == c.object_id
 => true

Conversão de Objetos
Várias classes no ruby definem métodos que retornam uma representação do objeto como um valor de uma classe distinta. O método to_s, por exemplo, é utilizado para obter uma representação em String de um objeto.

Algumas conversões são explícitas: to_s (String), to_i (Integer), to_f (Float), to_a (Array). Outras são implícitas, em alguns casos quando a classe possui características marcantes de outra classe.

Copiando Objetos
A classe Object possui dois métodos bastante parecidos para lidar com cópias de objetos. Tanto o clone ou dup retorna uma cópia superficial do objeto sobre o qual eles são chamados. Se o objeto copiado possuir um estado interno que se referencie a outros objetos, apenas as referências do objeto serão copiadas, não os próprios objetos referenciados.

Se o objeto que está sendo copiado em questão define um método initialize_copy, clone e dup alocam uma instância nova e vazia da classe e chamam o initialize_copy nessa instância vazia. O objeto em questão a ser copiado é passado como um argumento e essa “cópia do construtor” pode inicializar a cópia como ela desejar.. Por exemplo, o método initialize_copy poderia copiar recursivamente os dados internos de um objeto de modo a que o objeto resultante não seja uma simples cópia superficial do original.

As classes também podem sobrescrever diretamente o método clone e dup para resultarem qualquer cópia que desejarem.

Existem duas diferenças importantes entre os métodos clone e dup que são definidos pela classe Object. Em primeiro lugar, clone copia tanto o estado freeze e o tainted (definido em primeira instância) de um objeto, enquanto que dup apenas copia o estado tainted; chamando dup em um objeto freeze retorna uma cópia sem o estado freeze. Em segundo lugar, clone copia todos os métodos singleton do objeto, enquanto o dup não.

Empacotando (serializando) objetos
Você pode salvar um estado de um objeto ao passá-lo como parâmetro para um método de classe Marshal.dump. Caso você passe um objeto de Entrada/Saída como segundo argumento, Marshal.dump determina o estado do objeto (e recursivamente, qualquer objeto que esteja sendo referenciado), caso contrário retorna um estado codificado como String binária.

Para recuperar um objeto serializado, passe uma string ou um fluxo de entrada/saída contendo o objeto para o método Marshal.load.

Serializar um objeto é um jeito bacana de guardar o estado para um uso futuro, além do que esses métodos podem ser utilizados para fornecer um formato automático de arquivos para apps em Ruby.

Congelando Objetos
Qualquer objeto pode ser “congelado” ao chamar o método freeze. Um objeto “congelado” é considerádo imutável – isto é, nenhum de seus estados podem ser modificados e a tentativa de chamar qualquer método que seja capaz de modificar será falha.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

ruby-1.9.2-p136 :001 > s = "ice"
 => "ice"
ruby-1.9.2-p136 :002 > s.freeze
 => "ice"
ruby-1.9.2-p136 :003 > s.frozen?
 => true
ruby-1.9.2-p136 :004 > s.upcase!
RuntimeError: can't modify frozen string
    from (irb):4:in `upcase!'
    from (irb):4
    from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands/console.rb:44:in `start'
    from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands/console.rb:8:in `start'
    from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands.rb:23:in `'
    from script/rails:6:in `require'
    from script/rails:6:in `'
ruby-1.9.2-p136 :005 > s[0] = "ni"
RuntimeError: can't modify frozen string
    from (irb):5:in `[]='
    from (irb):5
    from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands/console.rb:44:in `start'
    from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands/console.rb:8:in `start'
    from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands.rb:23:in `'
    from script/rails:6:in `require'
    from script/rails:6:in `'
ruby-1.9.2-p136 :006 >

ruby-1.9.2-p136 :001 > s = "ice"
 => "ice"
ruby-1.9.2-p136 :002 > s.freeze
 => "ice"
ruby-1.9.2-p136 :003 > s.frozen?
 => true
ruby-1.9.2-p136 :004 > s.upcase!
RuntimeError: can't modify frozen string
	from (irb):4:in `upcase!'
	from (irb):4
	from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands/console.rb:44:in `start'
	from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands/console.rb:8:in `start'
	from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands.rb:23:in `'
	from script/rails:6:in `require'
	from script/rails:6:in `'
ruby-1.9.2-p136 :005 > s[0] = "ni"
RuntimeError: can't modify frozen string
	from (irb):5:in `[]='
	from (irb):5
	from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands/console.rb:44:in `start'
	from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands/console.rb:8:in `start'
	from /Users/urieljuliatti/.rvm/gems/ruby-1.9.2-p136@rails-3.0.1/gems/railties-3.0.1/lib/rails/commands.rb:23:in `'
	from script/rails:6:in `require'
	from script/rails:6:in `'
ruby-1.9.2-p136 :006 >

Objetos Estranhos ou Duvidosos.

*Tentei encontrar alguma tradução eficiente para Tainted Objects, sem sucesso.

Geralmente, as aplicações web devem manter o controle de dados derivados da entrada de um usuário não confiável para evitar ataques de injeção SQL e tasks de segurança semelhantes.

O Ruby fornece uma solução simples para esse problema: Qualquer objeto pode ser marcado como “duvidoso”, chamando-o pelo método taint. E isso gera uma reação em cadeia, pois a partir do momento que um objeto é setado como taint, qualquer objeto derivado será taint também.

Segue o exemplo para analisarmos o que acontece quando setamos um objeto como taint:

1
2
3
4
5
6
7
8
9
10

ruby-1.9.2-p136 :001 > s = "untrusted"
=> "untrusted"
ruby-1.9.2-p136 :002 > s.taint
=> "untrusted"
ruby-1.9.2-p136 :003 > s.tainted?
=> true
ruby-1.9.2-p136 :004 > s.upcase.tainted?
=> true
ruby-1.9.2-p136 :005 > s[3,4].tainted?
=> true

ruby-1.9.2-p136 :001 > s = "untrusted"
=> "untrusted"
ruby-1.9.2-p136 :002 > s.taint
=> "untrusted"
ruby-1.9.2-p136 :003 > s.tainted?
=> true
ruby-1.9.2-p136 :004 > s.upcase.tainted?
=> true
ruby-1.9.2-p136 :005 > s[3,4].tainted?
=> true

É uma abordagem que será interessante ter uma cobertura específica, pois envolve questões de segurança e de como o Ruby lida com isso. Portanto, resumi apenas demonstrá-los do poder que a linguagem possui, pois infelizmente não terá como cobrir todo o tema. Futuramente pretendo estudar alguns critérios específicos sobre essa abordagem do Ruby

Por fim, gostaria de informar que a próxima abordagem será sobre Classes e Módulos.

Bons estudos a todos!

Referências:

http://www.devarticles.com/c/a/Ruby-on-Rails/Ruby-Classes-and-Objects/1/

http://rubylearning.com/blog/2010/11/03/do-you-understand-rubys-objects-messages-and-blocks/

http://www.hokstad.com/ruby-object-model.html

http://www.linuxtopia.org/online_books/programming_books/ruby_tutorial/Locking_Ruby_in_the_Safe_Tainted_Objects.html

Hoje o assunto é Symbol e pelo o que andei lendo na internet, somado ao livro que estou acompanhando, ele é um enorme enigma para vários programadores. Se você experimentar procurar na internet sobre o assunto, vai encontrar diversas discussões e diversas opiniões sobre a relevância do uso de Symbol.

Funcionamento: Em uma implementação comum , o interpretador do Ruby mantém uma tabela da classe Symbol que reserva os nomes de todas as classes, métodos e variáveis que se conhece. Isto permite que o interpretador evite comparações exageradas na cadeia de Strings, ele tenta sempre referir a nomes de métodos por sua posição nesta tabela de símbolos.

O engraçado do Symbol é a forma de inicialização ou instanciamento da própria classe:

1

  la_symbol

  la_symbol

Normalmente, para inicializar uma classe usa-se a chamada “new” procedida pelo método ‘initialize’ definido dentro da classe.

Lendo um artigo do Akita, além de ter uma cobertura mais abrangente do tópico que estou lendo no livro do Matz, descobri que o método initialize da classe Symbol é privado, isto é, ele força todo símbolo a ser instanciado com a notação de dois-pontos.

Um dos motivos dos símbolos existirem é que se toda hora instanciarmos uma String, estaremos criando vários objetos para uma mesma causa onde o problema poderia ser resolvido por constantes. Vamos visualizar como isso fica?

1
2
3
4
5
6
7
8
9
10

<pre>ruby-1.9.2-p136 :002 > "string".object_id
=> 2154639100
ruby-1.9.2-p136 :003 > "string".object_id
=> 2154627240
ruby-1.9.2-p136 :004 > "string".object_id
=> 2154611460 # veja quantos ids diferentes foram criados..
ruby-1.9.2-p136 :005 > :string.object_id
=> 108168
ruby-1.9.2-p136 :006 > :string.object_id
=> 108168 # percebam o mesmo id para os simbolos

<pre>ruby-1.9.2-p136 :002 > "string".object_id
=> 2154639100
ruby-1.9.2-p136 :003 > "string".object_id
=> 2154627240
ruby-1.9.2-p136 :004 > "string".object_id
=> 2154611460 # veja quantos ids diferentes foram criados..
ruby-1.9.2-p136 :005 > :string.object_id
=> 108168
ruby-1.9.2-p136 :006 > :string.object_id
=> 108168 # percebam o mesmo id para os simbolos

Essa solução já existe em outras linguagens, porém no Ruby, ao invés de declarar uma constante

1

 CATEGORY = "category"

 CATEGORY = "category"

e depois usá-la

1

 belongs_to CATEGORY 

 belongs_to CATEGORY 

o Ruby encontrou uma maneira mais elegante de tratar esse caso, especificamente sobre a sua sintaxe.

Para concluir: O principal objetivo dos símbolos é “ser tão eficiente em consumo de memória quanto constantes mas tão agradáveis aos olhos como strings” (via @akitaonrails).

Existem mais coisas sobre Symbols por aí na web, o que encontrei foi meio confuso

Por fim, nosso próximo post será sobre Objetos, que será bem abrangente!

Hoje tive que lidar com uma configuração de ambiente de testes com RSpec2, pois estou começando no mundo dos testes e queria aplicar alguns conceitos no meu blog que está sendo feito do zero em Rails. O objetivo desse quick post é apenas configurar o ambiente, não vou falar dos testes em si.

Uma vez com a sua aplicação já criada, no seu Gemfile, adicione as linhas:

1
2
3

group :development, :test do
  gem 'rspec-rails'
end

group :development, :test do
  gem 'rspec-rails'
end

Agora rode o bundle no terminal para instalar a gem que acabamos de associar ao Gemfile:

1

bundle install

bundle install

E para finalizar, precisamos rodar o generator do RSpec. Ele será responsável por criar alguns arquivos que falarei em seguida. Digite no terminal:

1

rails generate rspec:install

rails generate rspec:install

Como havia dito, esse comando vai gerar alguns arquivos, tais como:

- .rspec – Um arquivo de configuração onde podemos guardar algumas linhas de comando extras para se comunicar com a ferramenta rspec.

- spec – Um diretório que irá conter todos os arquivos de models, controllers, views, aceitação e outros tipos de arquivos spec para a sua aplicação.

- spec/spec_helper.rb – Um helper que será carregado a cada chamada do spec. Ele prepara todo o ambiente de teste, contendo a maioria das configurações do spec, arquivos de ajuda e etc.

Agora toda vez que você criar um Model ou um Controller via rails generator ou scaffolding, ele vai gerar também um arquivo para o spec.

1
2
3
4
5
6

$ rails g model teste
      invoke  active_record
      create    db/migrate/20110817125934_create_testes.rb
      create    app/models/teste.rb
      invoke    rspec
      create      spec/models/teste_spec.rb

$ rails g model teste
      invoke  active_record
      create    db/migrate/20110817125934_create_testes.rb
      create    app/models/teste.rb
      invoke    rspec
      create      spec/models/teste_spec.rb

Após compor o teste, para rodar junto à sua aplicação faça um rake spec:models (no nosso do teste), rake spec para integração, rake spec:views para views e assim vai

É isso aí!

Abraços.