{:elf => "Blog"}

Andei fazendo uns teste com o plugin Paperclip, ele é um plugin para upload de arquivos em projetos rails, com ele você pode implementar um esquema de upload de arquivos em seu sistema de forma rápida e confiavel, e com grande números de posibilidades de configurações, depois de dar uma mexida bem básica com ele resolvi escrever algo sobre, então aqui nesse post vamos ver como usar esse plugin em um projeo rails.

Não será um post combrindo tudo do paperclip, apenas o básico para ver ele funcioando em um aplicação rails.

Não vou partir com o pensamente de que já tenho alguma coisa feita, vamos criar uma nova aplicação Rails, apenas um CRUD e implementar o paperclipe em cima.

Bom antes de começar, algumas “revelações” , estou rodando isso em um Ubuntu 8.10, com Rails 2.1.2 e o Banco de Dados Mysql, dito isso vamos começar.

1 – Criando um simples projeto Rails.

Comece criando uma aplicação rails normalmente, então:

rails demopaper

Pronto o esqueleto de um projeto Rails está criando, vamos entrar nele agora e fazer a configuração do banco de dados, o Rails 2.1.2 vem com o arquivo de configuração do banco para o db SqlLite, aqui vamos usar o mysql.

Abra o arquivo em config/database.yml, ele vai ter o seguinte conteudo.

# SQLite version 3.x
#   gem install sqlite3-ruby (not necessary on OS X Leopard)
development:
   adapter: sqlite3
   database: db/development.sqlite3
   timeout: 5000

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
   adapter: sqlite3
   database: db/test.sqlite3
   timeout: 5000

production:
   adapter: sqlite3
   database: db/production.sqlite3
   timeout: 5000

Então apgue tudo e mude para usar o banco mysql:

development:
   adapter: mysql
   encoding: utf8
   database: demo_paper_development
   username: root
   password: sua_senha
   host: localhost

test:
  adapter: mysql
  encoding: utf8
  database: demo_paper_test
  username: root
  password: sua_senha
  host: localhost

production:
  adapter: mysql
  encoding: utf8
  database:
  username: root
  password: sua_senha
  host: localhost

Nesse momento os bancos que especificamos acima ainda não estão criandos então vamos criá-los.

Entre no terminal no Mysql e digite:

mysql> create database demo_paper_development;
mysql> create database demo_paper_test;

Feito. A parte de configuração de banco está feita.

2 – CRUD com Scaffold

Todas já sabem que o uso de scaffold é uma mão na roda, mas lembrando novamente RAILS NÃO é SCAFFOLD, ele server apenas para criar um CRUD rápido, mas você logicamente pode modificar tudo o que ele criar para você, então vamos lá, entre no terminal na pasta em que você criou o projeto e digite:

./script/generate scaffold usuario username:string

esse comando cria o model, o arquivo de migração, o controller e as views automaticamente, os arquivos de migração ficam em /db/migrate/ temos o seguinte nele:

class CreateUsuarios < ActiveRecord::Migration
   def self.up
      create_table :usuarios do |t|
         t.string :username
         t.timestamps
     end
 end

   def self.down
      drop_table :usuarios
   end
end

Agora precisamos rodar uma tarefa rake para gravar as informações descritar no arquivo acima no banco, então:

rake db:migrate

Agora já temos o que ver, então iniciamos o servidor com ./script/server e acessamos

http://localhost:3000/usuarios temos o seguinte:

Agora podemos adicionar um usuário:

Então agora temos um usuario cadastrado:

Bom algo muito simples, agora vamos ao que realmente importa de verdade: a implementação do Plugin Paperclip.

3 – Instalação do Plugin.

./script/plugin install git://github.com/thoughtbot/paperclip.git

Pronto plugin instalado

Agora vamos criar uma migration para adicionar novos campos no banco de dados para receber uma imagem:

No terminal digite:

./script/generate migration AddPhotoToUsuarios

Com isso ganhamos um novo arquivo de migration db/migrate/20081115184049_add_photo_to_usuarios.rb

vamos editar ele, deixe ele assim:

class AddPhotoToUsuarios < ActiveRecord::Migration
   def self.up
      add_column :usuarios, :photo_file_name, :string
      add_column :usuarios, :photo_content_type, :string
      add_column :usuarios, :photo_file_size, :integer
      add_column :usuarios, :photo_updated_at, :datetime
   end

   def self.down
      remove_column :usuarios, :photo_file_name
      remove_column :usuarios, :photo_content_type
      remove_column :usuarios, :photo_file_size
      remove_column :usuarios, :photo_updated_at
  end
end

Rodando o rake db:migrate novamente para gravar as informações no banco.

Agora vamos até o model e o deixamos assim:

class Usuario < ActiveRecord::Base
   has_attached_file :photo, :styles => {:small => "150x150>"}
end

Nessa linha temos um simbolo :photo que é mesmo que temos na migration.

Definiamos também um estilo small onde a foto irá ser redimencionada para 150×150, aqui você pode definir quantos estilos quizer, então vamos adicionar mais um estilo, mude seu model para:

class Usuario < ActiveRecord::Base
   has_attached_file :photo, :styles => {:small => "150x150>",
                                                                  :medium =>"400x400>"}
end

Pronto agora temo dois estilos diferente para a foto, aqui me refiro a estilo como o tamanho da imagem.

4 – Arrumando as Views

Feito isso vamos cirar um partial para deixar a coisa mais organizadas, crie um arquivo chamado _form.html.erb acresentando o campo da imagem :

   <% form_for(@usuario, :html => {:multipart => true}) do |f| %>
   <%= f.error_messages %>

     <strong><%= f.label :username %>:</strong>

     <%= f.text_field :username %>

     <strong><%= f.label  hoto %>:</strong>

   <%= f.file_field :photo %>

     <%= f.submit "Go!" %>

<% end %>

Vamos usar essa partial em nossas views, então vamos começar pela new, abra o arquivo new.html.erb e o edite deixando dessa forma:

<h1>Novo usuario</h1>
   <% form_for(@usuario,:html => { :multipart => true }) do |f| %>
      <%= render :partial => 'form', :locals => { :f => f } %>
  <% end %>

<%= link_to 'Voltar', usuarios_path %>

E no edit.html.erb

<h1>Editing usuario</h1>
<% form_for(@usuario,:html => { :multipart => true }) do |f| %>
   <%= render :partial => 'form', :locals => { :f => f } %>
<% end %>

<%= link_to 'Ver', @usuario %> |
<%= link_to 'Voltar', usuarios_path %>

Agora temos + – isso aqui:

No show.html.erb vamos chamar a imagem então:

   <strong>Username:</strong>
   <%=h @usuario.username %>

   <strong>Photo:</strong>

   <%= image_tag @usuario.photo.url(:small) %>

   <%= image_tag @usuario.photo.url(:medium) %>

   <%= link_to 'Editar', edit_usuario_path(@usuario) %> |
   <%= link_to 'Voltar', usuarios_path %>

Repare que chamos os dois estilos que criamos :small e :medium, agora em show temos:

E ai está a foto, nos dois tamanhos configurados no model.

Localização dos Uploads, por padrão ele irá mandar as foto para public/photos em uma estrtura de diretorios assim:

É isso ai, se alguem entrar um erro faça-me saber. t+
Abraço

Nessa segunda parte vamos dar uma olhada em alguns outros métodos de array, o ruby possue vários métodos para manipulação de array, e como disse no primeiro post array podem se comportar dinamicamente.

Não irei listar aqui todos os métodos disponiveis para manipulação de de array, apenas alguns que acho “legais”.

Vamos começar com um bem simples que apenas limpa um array, então de volta para o IRB temos:

O método clear.

>> a = %w(1 2 3 4 5 6)
=> ["1", "2", "3", "4", "5", "6"]
>> a.clear
=> []
>> a
=> []

Simplesmente remove todos os elementos do array.

O método empty?

Esse método retorna true se o array esta vazio e  e false se  contem algum elemento:

>> a
=> []
>> a.empty?
=> true
>>

Muito simples não ?

O método include?

O método include? retorna true se um objeto esta presente no array:

>> a = %w(a b c d e f)
=> ["a", "b", "c", "d", "e", "f"]
>> a.include?("f")
=> true
>> a.include?("r")
=> false
>>

O método replace.

Substitui o conteudo de um array pelo conteudo de outro, sua sintaxe é a seguinte:

array.replace(outro_array)

>> v = %w(a b c d e f)
=> ["a", "b", "c", "d", "e", "f"]
>> a.replace(%w[p e d c ])
=> ["p", "e", "d", "c"]
>>

O método delete

Esse método possue as seguintes sintaxes:

array_name.delete(objeto)
array_name.delete(objeto) { bloco }

esse método deleta todos os itens passados como parametros do array.
seja um exemplo:

>> v
=> ["1", "1", "1", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
>> v.delete("1")
=> "1"
>> v
=> ["2", "3", "4", "5", "6", "7", "8", "9", "10"]
>>

Ahh você lembra dos blocos?? legal vamos usar um bloco aqui, veja so:

>> v
=> ["2", "3", "4", "5", "6", "7", "8", "9", "10"]
>> v.delete("56") {puts "Nao encontrado"}
Nao encontrado
=> nil
>>

O método delete_at.

Semelhante ao método delete mas com a diferença que se passa o indice do elemento que se quer deletar.

=> ["2", "3", "4", "5", "6", "7", "8", "9", "10"]
>> v.delete_at(0)
=> "2"
>>

O método delete_if

Esse método recebe um bloco e se a condição dele for verdadeira deleta todos elementos da condição.

>> a =  %w(1 10 10 23 45 56)
=> ["1", "10", "10", "23", "45", "56"]
>> a.delete_if {|y| y > "10"}
=> ["1", "10", "10"]

o Método array.uniq

Esse método retorna um novo array sem os elementos duplicados do array:

>> a  = %w(a b c d e e e d d d f )
=> ["a", "b", "c", "d", "e", "e", "e", "d", "d", "d", "f"]
>> a.uniq
=> ["a", "b", "c", "d", "e", "f"]
>>

O &

Ah lembradas intersecções ?? podemos obter isso de maneira facil em ruby usando o &, seja:

>> a = %w(1 1 3 3 54 5)
=> ["1", "1", "3", "3", "54", "5"]
>> b = %w(1 3 4 4 4 5 5 1)
=> ["1", "3", "4", "4", "4", "5", "5", "1"]
>> a & b
=> ["1", "3", "5"]
>>

Array se comportam Dinamicamente.

Array em ruby podem ter seus tamanhos modificados de maneira fácil e rápida sem atulização de ponteiros e tudo mais como é o caso de C por exemplo.

Vamos fazer um exemplo de uso de uma pilha, uma pilha é uma estrutura de dados do tipo LIFO (last in, first out), ou seja o ultimo elemento a entrar é o primeiro a sair, então temos o push para inserir algum elemento no topo da pilha e o pop para deletar do inicio da pilha.

Exemplos:

>> a = []
=> []
>> a.length
=> 0
>> a.push("a")
=> ["a"]
>> a.push("b")
=> ["a", "b"]
>> a.push("c")
=> ["a", "b", "c"]
>> a.pop
=> "c"
>> a.length
=> 2

Bom, simples não, vimos que nosso array se comportou dinamicamente aumentando e diminuindo de tamanho conforme a necessidade.

Também temos os métodos unshift e shift, o primeiro insere um elemento no inicio do array, e o segundo deleta um elemento do inicio do array.

Parece ser semelhante ao push , a diferença é que o push coloca um elemento no TOPO do array e o unshift coloca no inicio do array, e consequentemente o pop deleta do topo e o shift deleta no inico.

OBS: Você so pode usar os métodos shift e pop se o array não estiver vazio, para ver se está vazio você já sabe neh? não?. . . array_name.empty? … lembrou ? ok.

Bom esse é o final da segunda parte, não sei se vai ter uma terceira , obviamente esse post e o primeiro contém erros e espero que alguem que venha a ler isso faça-me saber dos erros deixando um cometário aqui, é claro que tem muito mais a ser visto sobre array, blocos, . . . e tudo mais, Obrigado, abraço a todos.

Referência:

http://www.ruby-doc.org/core/classes/Array.html

Arrays ou vetor ou lista caso for um vetor uni-dimensional é uma estrutura de dados na qual são armazenados geralmente vários items de um mesmo tipo(int por exemplo), os elementos pertencentes ao array podem ser acessados usando o índice (subscrição)do array ou seja sua posição, array normalmente tem a limitação de terem um tamanho fixo, ou seja, um tamanho estático que não pode ser mudado,  veremos na segunda parte desse post que em ruby os array ou vetores podem se “comportar” de tal maneira.

Criando Array em Ruby.

Para começar abra o melhor amigo seu … sabe quem é? Isso mesmo o irb, bom vamos lá:

coisas = ["caneta", "livro", "cadeira"]
["caneta", "livro", "cadeira"]

Simples não? Agora temos um array chamado coisas contendo três nomes de “coisas”. Lembre-se que arrays começam em 0 e vão ate n-1.

Não Faça isso: Nunca começe um array em 1, à não ser que tenha bons motivos para faze-lo.

Bom, agora temos um array de strings chamado coisas que aramazena tres “coisas” e seus indíces e são respectivamente 0,1 e 2.

Podemos separar um array por espaços em branco, usando o %w.

>> coisas = %w(caneta livro cadeira)
=> ["caneta", "livro", "cadeira"]

Podemos também criar arrays em “pedaços” da seguinte maneira.

>> coisas = Array.new
=> []
>> coisas << 'caneta'
=> ["caneta"]
>> coisas << 'livro'
=> ["caneta", "livro"]
>> coisas << 'cadeira'
=> ["caneta", "livro", "cadeira"]

Pois bem, agora vamos acessar os elementos do array, como disse antes arrays começam em zero então não cometa o erro de querer acessar o primeiro elemento fazendo asocição a posicão 1 do array, ao invés da 0.

>> a_coisas = coisas[0]
=> "caneta"
>> a_coisas = coisas[1]
=> "livro"
>> a_coisas = coisas[2]
=> "cadeira"
>>

Como você pode ver funciona como a maioria das linguagens de programação, claro que o Pascal começa um vetor em 1( não sei porque), mas esqueça o pascal .

O método each.

Each em portugês quer dizer “cada”, vamos fazer um exemplo que chama um bloco uma vez para cada item do array, passando como paramêtro ele mesmo, e concatenando com algum caractere como uma “,” ou uma string.

>> coisas
=> ["caneta", "livro", "cadeira"]
>> coisas.each do |coisa|
?>   puts "#{coisa} e muito legal"
>> end
caneta e muito legal
livro e muito legal
cadeira e muito legal
=> ["caneta", "livro", "cadeira"]
>>

a variavel c se refere a cada item do array, no comando puts usando

“#{coisa} e muito legal” assim podemos inserir uma variavel dentro da string.

Não mencionei uma coisa nesse exemplo, mas acredito que você deve saber, usamos blocks,Blocos são usados extensivamente em Ruby.

Não está nos planos desse post falar sobre blocos mas já que entramos no assunto um pouco não faz mal a ninguém.

Saindo dos “rails” – Um pouco de Bloks.

Blocos são um dos recursos mais legais que o ruby tem, com ele você tem a capacidade de pegar um determinado bloco de código (isso mesmo o que esta entre o do e o end) e “colocar” tudo isso em um objeto que é chamado de proc, então jogar tudo isso em uma variavel, podemos passar para métodos(não vamos ver isso), usarmos esse bloco de código quantas vezes der da telha , ou seja ele é um objeto, exemplo:

>> oi = Proc.new do
?>    puts 'Welcome to the jungle'
>> end
=> #<proc:0xb7b6e894@(irb):39>
>> oi.call
=>Welcome to the jungle
=> nil
>> oi.call
Welcome to the jungle
=> nil

Blocos podem receber paramêtros também,podemos criar métodos que retornem procs, etc, etc, de uma olhada na documentação do ruby sobre Blocks e Procs.

Agora um pouco do each_with_index

Funciona da mesma forma que o each, mas passa também o indice do elemento ao invés de somente do elemento.

>> coisas.each_with_index do |c, ind|
?>    puts "#{c}  esta no indice #{ind}"
>> end

=> caneta  esta no indice 0
=> ivro  esta no indice 1
=> cadeira  esta no indice 2

O método MAP

Chama um bloco uma vez para cada elemento do array, e cria um novo array com os valores que o bloco devolveu, exemplo:

>> x = coisas.map do |con|
?>    "1 #{con}"
>> end
=> ["1 caneta", "1 livro", "1 cadeira"]
>>

Uma coisa a se notar é que não foi necessário usar o palavra return como em outras linguagens, em um bloco Ruby retorna automaticamente o valor da ultima interação do bloco.

Bom para inicio é isso, logo teremos a segunda parte…. abraço a todos.