Blog Patrick Espake

Uma forma simples de testar escopos no model é a seguintes:

O Model:

class User < ActiveRecord::Base
  # The scopes for search
  scope :signed, where("sign_in_count > 0")
end

O Teste RSpec:

# encoding: utf-8
require 'spec_helper'
 
describe User do
  describe "scopes" do
    it "should returns the signed users" do
      User.signed.to_sql.should == User.where("sign_in_count > 0").to_sql
    end
  end
end

Para fazer os testes pararem quando o primeiro teste falhar, basta adicionar a linha:

--fail-fast

No seu arquivo .rspec, localizado na raiz do projeto Rails.

Ficando o arquivo da seguinte forma:

--colour
-p
--fail-fast

Curitiba não tem muitos desenvolvedores em Ruby on Rails.
E o cenário de inovação e startups lá está caminhando, mas não temos muitas empresas surgindo por lá.

Em Curitiba eu já estudei nas seguintes universidades: Universidade Positivo, UTFPR e PUCPR. Fazendo graduação e pós-graduação nessas universidades, eu sempre tive uma crítica muito forte a respeito das universidades em Curitiba, elas preparam os alunos para as grandes corporações como HSBC, GLT, GVT e outras, que usam tecnologias como Java e C#, mas raramente falam de tecnologias emergentes como Ruby, Python e outras, e raramente preparam os alunos para inovação e empreendedorismo tecnológico. Claro que existem pós-graduações em Empreendedorismo tecnológico e inovação tecnológica.

Outro fator em Curitiba é a questão de salários, os salários em Curitiba são medianos na área de tecnologia, por exemplo um ótimo desenvolvedor no regime CLT deve receber em torno de R$ 3.500,00 e se for no regime PJ em torno de R$ 5.000,00. Esse salário não é atrativo para um desenvolvedor com excelência, então é comum você ver os desenvolvedores migrando pra outros polos como São Paulo, Rio de Janeiro e outros muito bons indo para São Francisco.

Outro fator importante é que a cidade precisa ter eventos de tecnologia, é necessário ter essa cultura, pessoas e empresas incentivando esses eventos, em Curitiba eles caminham de forma muito lenta.

É importante é que o lugar tenha a cultura nerds e tenha interação entre essas pessoas, porque são essas pessoas que vão construir o cenário local e influenciar outras pessoas.

Por exemplo eu trabalhei durante quase 2 anos na Siemens Enterprise Communications, uma grande multinacional em Curitiba, acabei indo para uma multinacional pelo fato de não ter nenhuma outra empresa que eu ache-se interessante de trabalhar em Curitiba, que tivesse um ambiente inovador, dinâmico, com pessoas transpirando tecnologia e usando tecnologias interessantes. Curitiba está pobre de empresas com ambiente legal e projetos interessantes, inovando e usando tecnologias emergentes.

Eu morei por 27 anos em Curitiba, e faz 1 mês que eu me mudei para o Rio de Janeiro.
O Rio de Janeiro está vivendo uma bolha de internet e startups, está se tornando um polo muito forte de desenvolvimento web, tem muita gente boa aqui, do Brasil inteiro.

Tem muitos eventos de tecnologia acontecendo no Rio de Janeiro, tem muitos investidores também, e várias startups estão surgindo e aqui, e muitas outras estão migrando pra cá. Por exemplo o Peixe Urbano.

Comparando Curitiba e o Rio de Janeiro, eu diria que:

• Curitiba equivale a uma pessoa de 40 anos, que tem família, que busca um emprego estável e não quer arriscar; Perfil geração X.
• Rio de Janeiro equivale a uma pessoa de 20 anos, que não tem família, que não tem medo de arriscar, entende que o risco faz parte da vida, e acha isso parte da diversão, transpira novidades, e de alguma forma quer fazer a diferença e se destacar; Quer trabalhar de bermuda e camiseta, quer liberdade para criar e desenvolver o seu trabalho. Perfil geração Y.

Essa é uma opinião extremamente pessoal, baseada na minha experiência de vida em Curitiba.

Se você criar uma migração para popular dados no banco de dados e as strings contiverem acentos ou caracteres especiais é bem provavelmente que você vai ter alguns erros de parse no código Ruby:

Por exemplo:

class PopulateTests < ActiveRecord::Migration
  def up
    data = [['Saúde', 'Bla bla bla'], ['Cabeça', 'Ble ble ble'], ['João', 'Belipx Blopx']]
    data.each do |item|
      test = Test.create(:name => item[0])
      test.save
    end
  end
 
  def down
    Test.delete_all
  end
end

Normalmente essa migração vai dar problema para rodar, devido aos caracteres de acentos e outros.

Para resolver isso bastar colocar no começo da sua migração: #encoding: UTF-8
Ficando o arquivo assim:

#encoding: UTF-8
 
class PopulateTests < ActiveRecord::Migration
  def up
    data = [['Saúde', 'Bla bla bla'], ['Cabeça', 'Ble ble ble'], ['João', 'Belipx Blopx']]
    data.each do |item|
      test = Test.create(:name => item[0])
      test.save
    end
  end
 
  def down
    Test.delete_all
  end
end

A forma mais elegante que eu encontrei para testar associações no rspec é a seguinte:

describe Group do
      it { should belong_to(:supergroup) }
      it { should have_many(:users) }
end

Utilizando a gem shoulda-matchers: https://github.com/thoughtbot/shoulda-matchers/.

Quando nós desenvolvemos aplicações usando test-driven development sempre temos que rodar o comando:

rake spec

mas isso é um pouco chato e trabalhoso. Para facilitar a nossa vida existe o “Guard“, a ideia do “Guard” e rodar os testes automaticamente toda vez que algum arquivo associado ao teste for alterado.

O “Guard” pode ficar monitorando vários tipos de arquivos diferentes, desde o rspec, até as alterações de html e css no site. Uma outra extensão interessante do “Guard” é o “livereload“, ele dá um refresh no browser automaticamente toda vez que algum arquivo relacionado com a view é alterado.

Para instalar o Guard, no Gemfile adicionar:

group :development, :test do
  # ...
  gem 'rb-fsevent', :require => false if RUBY_PLATFORM =~ /darwin/i
  gem 'guard-rspec'
  gem 'guard-livereload'
  gem 'yajl-ruby'
  gem 'rack-livereload'
end

Depois rodar no terminal:

bundle
guard init rspec
guard init livereload
guard

Na raiz do projeto será gerado o arquivo Guardfile, com as configurações do Guard e todos os arquivos que são monitorados, algo como isso:

guard 'livereload' do
  watch(%r{app/.+\.(erb|haml)})
  watch(%r{app/helpers/.+\.rb})
  watch(%r{public/.+\.(css|js|html)})
  watch(%r{config/locales/.+\.yml})
end
 
guard 'rspec', :version => 2 do
  watch(%r{^spec/.+_spec\.rb})
  watch(%r{^lib/(.+)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
  watch('spec/spec_helper.rb') { "spec" }
 
  # Rails example
  watch('spec/spec_helper.rb')                       { "spec" }
  watch('config/routes.rb')                          { "spec/routing" }
  watch('app/controllers/application_controller.rb') { "spec/controllers" }
  watch(%r{^spec/.+_spec\.rb})
  watch(%r{^app/(.+)\.rb})                           { |m| "spec/#{m[1]}_spec.rb" }
  watch(%r{^lib/(.+)\.rb})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
  watch(%r{^app/controllers/(.+)_(controller)\.rb})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/requests/#{m[1]}_spec.rb"] }
  watch(%r{^app/views/(.+)/})                        { |m| "spec/requests/#{m[1]}_spec.rb" }
end

Para configurar o livereload, adicione no arquivo: config/environments/development.rb

MyApp::Application.configure do
  config.middleware.insert_before(Rack::Lock, Rack::LiveReload)
 
  # ...or, change some options...
 
  config.middleware.insert_before(
    Rack::Lock, Rack::LiveReload,
    :min_delay => 500,
    :max_delay => 10000,
    :port => 56789,
    :host => 'localhost:3000',
    :ignore => [ %r{dont/modify\.html$} ]
  )
end

Para o livereload (http://livereload.com/) funcionar é necessário também instalar uma extensão no browser, nesse exemplo no Firefox:

Você pode obter as extensões aqui: http://feedback.livereload.com/knowledgebase/articles/86242-how-do-i-install-and-use-the-browser-extensions-.

Usando o Simple Form é possível prover uma listagem de países.
Algumas vezes é interessante deixar um determinando país em destaque no select.

Para fazer isso basta adicionar a opção “:priority” na montagem do campo.

f.input :country, :priority => [ "Brazil" ]

Mais detalhes em: https://github.com/plataformatec/simple_form.

Ao invés de toda vez você rodar “rails server” para subir uma aplicação Ruby on Rails, você pode deixar ela rodando por padrão no seu servidor Apache em um endereço por exemplo: http://nome_da_sua_aplicacao

Para isso no terminal:

sudo apt-get install apache2
sudo apt-get install libapache2-mod-passenger

Agora no arquivo /etc/hosts adicione um nome local para a sua aplicação para responder no navegador:

127.0.0.1       localhost nome_da_sua_aplicacao
127.0.1.1       tron
 
# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

No meu caso adicionei nome_da_sua_aplicacao para responder localmente.

Agora será necessário adicionar a configuração do site no Apache, para isso:

sudo touch /etc/apache2/sites-available/nome_da_sua_aplicacao

Depois edite o arquivo acima e adicione o seguinte conteúdo:

        ServerAdmin webmaster@localhost
        ServerName nome_da_sua_aplicacao
 
        DocumentRoot /var/www/nome_da_sua_aplicacao/public
 
                Options FollowSymLinks
                AllowOverride None
 
                Options Indexes FollowSymLinks MultiViews
                AllowOverride None
                Order allow,deny
                allow from all
 
        ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
 
                AllowOverride None
                Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
                Order allow,deny
                Allow from all
 
        ErrorLog ${APACHE_LOG_DIR}/error.log
 
        # Possible values include: debug, info, notice, warn, error, crit,
        # alert, emerg.
        LogLevel warn
 
        CustomLog ${APACHE_LOG_DIR}/access.log combined
 
    Alias /doc/ "/usr/share/doc/"
 
        Options Indexes MultiViews FollowSymLinks
        AllowOverride None
        Order deny,allow
        Deny from all
        Allow from 127.0.0.0/255.0.0.0 ::1/128

Onde /var/www/nome_da_sua_aplicacao/public é o caminho da sua aplicação Ruby on Rails, mais exatamente o caminho até o diretório public dela.

E ServerName nome_da_sua_aplicacao é o nome que você deseja acessar via navegador o mesmo nome que configuramos no /etc/hosts.

Agora vamos criar um link simbólico para o site funcionar no Apache:

cd /etc/apache2/sites-enabled
sudo ln -s ../sites-available/nome_da_sua_aplicacao 001-nome_da_sua_aplicacao

Agora é a hora de reiniciar o servidor web Apache para pegar as novas configurações, para isso:

sudo /etc/init.d/apache2 restart

Agora se você abrir a URL http://nome_da_sua_aplicacao no seu navegador já deve ver o seu site rodando.

Você provavelmente vê essas mensagens de erro quando roda Rails 2.3.8 ou mais antigo no mesmo servidor com o novo Rails 3 para cima.

Para arrumar isso existe 2 possíveis soluções:

Solução 1:

1. Crie o arquivo: config/preinitializer.rb
2. Com o conteúdo abaixo:

   require 'rubygems'
   begin
     gem 'i18n', "~> 0.4.0"
   rescue LoadError
     # no biggie, optional anyway
   end

3. Reinicie o servidor web

Solução 2:

No terminal:

gem uninstall i18n
gem install i18n -v 0.4.0

Por favor recomende-me se esse post ajudou você:

If you tried to start Rails server and got this error:

/usr/lib/ruby/gems/1.8/gems/execjs-1.3.0/lib/execjs/runtimes.rb:50:in `autodetect': Could not find a JavaScript runtime. See https://github.com/sstephenson/execjs for a list of available runtimes. (ExecJS::RuntimeUnavailable)

In Ubuntu, you can fix it installing node.js:

sudo apt-get install python-software-properties
sudo add-apt-repository ppa:chris-lea/node.js
sudo apt-get update
sudo apt-get install nodejs
sudo apt-get install nodejs-dev

If you have other OS please look here: https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager

After you should starting Rails server with successful.

Please recommend me if this post help you: