• GEMs: Fácil gerenciamento, mostra o que está instalado, o que pode ser atualizado, novos gems e possibilidade de incluir novas URLS;
• Plugins: Idem ao item anterior;
• Editor: Percebi que o editor está mais rápido que de versões que avaliei anteriormente, principalmente com o code completion e os textos de ajuda, inclusive existe e funciona o code completion para os arquivos erb da camada view;
• Rake: Todas as task estão disponíveis e bem classificadas no menu; As tasks que são utilizadas são empilhadas no menu para rápido acesso;

Sempre utilizei o Eclipse, porém vou passar a utilizar o Netbeans 6.1 para continuar avaliando a IDE, pois o primeiro contato realmente agradou.

Envolva-se com Ruby:

Documentação: Consulte aqui.
Fórum: Ruby-Fórum.
Grupos: Ruby-talk-google.
e-Books: Aprenda a programar Ruby.

Envolva-se com Rails:

Documentação: Consulte aqui.

Foruns: Rails Brasil, Ruby on Br, Ruby-Fórum Rails.

Grupos: rails-br e Ruby on Rails:Talk

Tutorial: Rolling with Rails 2.0 by Fabio Akita: Parte 1 e Parte 2.

Podcasts: Rails Podcast Brasil

Screencasts: PeepCode (pago) e Railscasts (grátis)

Melhores blogs: Fabio Akita, Carlos Branco e Carlos Eduardo e-Genial.

Envolva-se com Flex:

Documentação: Consulte aqui.

Foruns: Fórum FlexBrasil e Fórum Informe Flex-Brasil

Grupos: Flex-Brasil Google, Flex-Brasil Yahoo, e Flexdev.

Tutorial: Seleção de 10 tutoriais sobre flex e flex on rails.

Podcasts: The flex show podcasts.

Screencasts: Adobe Flex Media Screencast.

Melhores blogs: The flex show, Fabio Terracini, Carlos Eduardo e-Genial.

Extras: Portal Flex, Flex Showcases.

Como uma forma de tentar evitar que meus caros amigos desenvolvedores iniciantes em ruby on rails e Flex percam seus preciosos tempos e queimem neurônios, criei este tutorial passo-a-passo, onde mostro quais softwares e versões que você precisa ter instalado em sua máquina para desenvolvedor aplicações RIA, flex on rails.

Composição do kit:

Basicamente o kit de softwares necessários para você desenvolver aplicações Flex on Rails, é o seguinte:

1) Mysql;

Versão recomendada: 5.0
Observação: Recomendo posteriormente a instalação da ferramenta Mysql-front para visualização mais rápida e dinâmica.
Clique aqui para baixar.

2) Ruby;

Versão recomenda: 1.8.6 última estável
Observação:
Clique aqui para baixar.

3) Rails;

Versão recomendada: 2.0.2 última estável
Observação: Deve ser instalado obrigatoriamente depois do ruby.
Link para download: abrir o cmd e digitar o seguinte comando: gem install rails --include-dependencies

4) Java Runtime;

Versão: 6 atualização 5
Observação: Utilizado pelo Flex 3 Builder e do Aptana RadRails, todos os 2 são derivados do eclipse.
Clique aqui para baixar.

5) Aptana Studio RadRails;

Versão: Aptana Studio 1.1 e do plugin RadRails 1.0.1
Observação: Primeiramente você deve baixar o Aptana Studio 1.1 e depois, do próprio software instale o plugin RadRails versão 1.0.1.
Clique aqui para baixar.

6) Adobe Flex 3 Builder;

Versão: 3.0
Observação: Este software é pago, porém no site do fabricante, Adobe, você poderá realizar um cadastro para obter versão trial por 90 dias.
Clique aqui para baixar.

Cronograma e Ordem da instalação:

1) Mysql, instale primeiramente o mysql 5.0 server na sua máquina, pois, durante a instalação dos softwares server-sides, como rails, ele buscará pelo mysql instalado para incluir o caminho (path) em sua biblioteca interna;

2) Ruby, todos sabemos que o rails é um framework da linguagem ruby, portanto para que o rails funcione você deve instalar primeiramente sua base, que é
o ruby.

3) Rails, depois de instalado o ruby, instale o rails que é muito simples e a instalação não poderia ser menos dinâmica que o framework, para instalá-lo basta abrir o cmd e digitar o seguinte comando:

gem install rails --include-dependencies

4) Java Runtime, como iremos trabalhar com IDE Aptana RadRails, cuja qual iremos instalar no próximo passo, como todos sabemos, todo aplicativo baseado no eclipse, usa a plataforma java, por isso, caso ainda não tenha, instale-a previamente antes do Aptana RadRails.

5) Aptana RadRails, como sabemos no mundo de hoje tempo é dinheiro, por isso, existem diversas editores que automatizam ainda mais as funções do rails, dentre elas está o Aptana Studio RadRails, que para mim, é a melhor ferramenta.

6) Adobe Flex 3 Builder, depois de tudo pronto agora só falta a parte charmosa e visual do seu kit, instale o flex 3 builder, que será a camada de visualização de sua aplicação feita em rails. Como todos sabemos, todas as apps rails utilizam a estrutura MVC, que significa, Model, View, Controller. Quando juntamos as tecnologias client-side Flex e server-side Rails, o flex incorpora a função das views da aplicação rails, que é no meu entender, o grande charme e transformação visual das aplicações, o que difere sua app das comuns estáticas que se vê por aí.

Bom por agora é só, espero que tenham gostado de mais esta contribuição. Abraço a todos!.

class SelfdiagnoseController < ActionController
  include SelfDiagnose

  tasks {
      check_database_connection 'mysql'
      check_directory_readable '/path/to/dir'
      check_log_writeable 'production.log'
      check_url_accessable 'http://s3browse.com'
  }
end

And the module would be defined as something similar to:

module SelfDiagnose
  def tasks
    yield if block_given?
  end
  def check_database_connection(db_name)
    # create a new CheckDatabaseConnection task and register it for running
  end
  def check_log_writeable(log_name)
    # create a new CheckLogWriteable task and register it for running
  end
end # module

Looking back at this approach, I don't see the need for having a task registration in the Rails version of SelfDiagnose. I might as well implement the controller like this:

class SelfdiagnoseController < ActionController
  include SelfDiagnose

  def index
      check_database_connection 'mysql'
      check_directory_readable '/path/to/dir'
      check_log_writeable 'production.log'
      check_url_accessable 'http://s3browse.com'
  end
end

Then, the index.html.erb will put together a nice report of the results.

Anyone developing using some relatively cutting-edge framework/methodology/language/frogs/shoes/moustach/... should be familiar with the "both the answer and the shit is blowin' in the wind" effect: simple sollutions attract good developers, good developers advertise what they work with, which brings new users, and the new users in fact attract the sharks.

The sharks -both literal ones and the ones manifested as coders- are pretty stupid creatures: they swimm around, trying to smell some blood (aka. copy'n'paste), and scare away anybody with some common sense left in 'em.

Rails was once nice. I've managed to spill out an app in a realtively short time with 0.9, which worked like a charm. And just like when you marry someone, after the first year the problems start to appear: she forgets to go to the gym, and, well... another year passes by and look... that fat b**ch wearing your wedding ring just isn't the one you supposed to live your life with...

And now github (no you fck'ers, I won't link you) opens up with a business plan like this . Geez, I've seen this somewhere... Does anyone remember when you first saw basecamp's similar page? A while ago, basecamp's version had the exact same number of rows and columns, with almost the same CSS classes and ID's.

Or perhaps is there a ruby gem called gem_business_plan? Anyway. The rails project just does what its name says: it lays the rails for you, and if you're lazy, the only direction you're heading is the exact same destination as the guys who laid the rails...

I'm really looking forward to some hidden gem found only in the dark corners of the net, some really exotic freakish 'ish toolset on a desert island...

[Update]

I'm really getting bored seeing the same signup/"plans" for a gajillion sites, so I've decided to create a little list I can expand when my frustration level exceeds the threshold.

• http://www.corepage.com
• https://scoutapp.com/subscriptions

[sourcecode language="ruby"]
def access_denied
respond_to do |format|
format.html do
store_location
redirect_to new_session_path
end
format.any do
request_http_basic_authentication 'Web Password'
end
end
end
[/sourcecode]

This code essentially says, if it's an html request, store the original request and redirect to the login page, any other requests get the 401 Unauthorized header which the user agent can then use to initiate an HTTP Auth. This bit of code only works correctly with Edge Rail's 8987 Changeset that allows any to act as a catch-all for any request mime-types not already specified.

Awesome!
Except when Internet Explorer 6 comes into the picture and happily sends this
strange and incomplete 'Accept:' header:

image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*

As you can see, it doesn't specify application/xhtml+xml or even text/html and what's worse is the subsequent requests to the same page sends the catch-all */*.

What does this all mean?
When IE6 navigates to a page that requires login, instead of redirecting the user to the login page, the user is presented with an HTTP Auth Dialog. What's worse is that in my application, cookies and other application state for an web-based end-user is set outside of the login_from_basic_auth method -- you know -- in my login action.

My guess is when the format.any fix goes out in the next rails release, IE6 users on acts_as_authenticated sites are going to be sad-faced. I'm not entirely sure the correct way to fix this problem but this is how I solved it in my application:

[sourcecode language="ruby"]
class ActionController::AbstractRequest
def accepts_with_faulty_header
@env['HTTP_ACCEPT']='*/*' if @env['HTTP_USER_AGENT'] =~ /msie/i and @env['HTTP_USER_AGENT'] !~ /opera|webtv/i
accepts_without_faulty_header
end
alias_method_chain :accepts, :faulty_header
end
[/sourcecode]

Originally, I thought to patch the Mime::Type.parse function, but decided that I wanted to make sure to look at the user agent for IE6. As you can see, I switch the HTTP_ACCEPT header to the catch-all */* string if the original HTTP_ACCEPT header is a match to the exact (bizarre) IE6 string and the HTTP_USER_AGENT is IE (matches MSIE but not Opera or WebTV). Then I call the original ActionController::AbstractRequest.accepts method.

I'd love to hear your ideas and suggestions -- and if others have run into this problem as I didn't find many users have this exact problem and how they may have solved it.

Update: Based on the conversation in the comments, I've re-written the patch to always change the HTTP_ACCEPT header to the catch-all */* if it is an IE Browser.

Most people doing JRuby on Rails development are using JMongrels¹ for development and some real Java Application Server in production.

The common flow is:

$ jruby script/server
=> Booting Mongrel (use 'script/server webrick' to force WEBrick)
=> Rails application starting on http://0.0.0.0:3000
=> Call with -d to detach
=> Ctrl-C to shutdown server
** Starting Mongrel listening at 0.0.0.0:3000
** Starting Rails with development environment...

code, code, test, code, code, test, ... (shouldn't it be red-green-refactor?)

$ jruby -S warble
$ cp myapp.war $TOMCAT_HOME/webapps
$ $TOMCAT_HOME/bin/startup.sh

Sure you can automate those things with ant, rake, sake or anything else. Some people are still using the goldspike-plugin, but be warned: I suspect it won't get much more attention.

The great Warbler from Nick Sieger is becoming the de facto standard for JRuby on Rails packaging. The Warbler's recent move from goldspike to JRuby-Rack adapter reveals two interesting points:

1. Goldspike is likely going to be deprecated (or merged with jruby-rack adapter?).
2. Warbler will soon package any rack compatible application to be runned inside Java Containers. Such applications include Merb, Sinatra, Vintage, Camping ones, and growing...

Although Warbler works really well, it introduces complexity in the development cycle. You can no more save code and immediately test it in your browser:

1. change code;
2. warble it;
3. deploy war file;
4. restart server; (takes long time)
5. open browser;
6. change code;
7. ...

It breaks one of the most important rails development characteristics: instant feedback. During development, it's very important to see changes without have to wait for server/context restarting.

JMongrel and Glassfish Gem are good candidates for JRuby on Rails development with instant feedback, but you can't use Java (Servlet specification) specific features, such as web.xml; they aren't complete Servlet Containers. Some things have an alternative in pure-rails as Servlet Filters and Servlet Listeners, but many haven't. Servlet Context might be a good way to share things between rails runtimes. I know railers should "share nothing", but -hey- sometimes it's so good to share!

You can take the Servlet Application Context as your in-memory cache store (fragment and page caching), eliminating the need for filesystem or database overhead and even memcached, in many cases.

I had also a specific reason to share the same HttpSession between Rails and "pure Java" applications. Single sign-on wasn't an option, so I needed to run both applications in the same context. I'm going to tell more about it soon.

Anyone can fall in cases, like mine, when you just can't use jmongrel or glassfish_rails. Now, we fortunately have jetty-rails to rescue!

It's a (one more) gem to run rails applications, based on the nice JRuby-Rack adapter, which I recommend you to take a look. Jetty is a very powerful Servlet Container, known for being pioneer at being embedded and at using NIO Connectors.

The gem creates a Jetty Server with two Handlers. The first is for static content and the last to serve dynamic requests using JRuby-Rack. These handlers are applied in order and request processing stops when one responds. That way, no rails code is runned to serve static content, improving response times. Take a look at the rdocs for more details.

Jetty is also very quick to start. I've measured (in a complete inaccurate way) some start times just for ugly² comparison:

$ jruby -v
ruby 1.8.6 (2008-03-28 rev 6360) [i386-jruby1.1]
$ time jruby script/server
=> Booting Mongrel (use 'script/server webrick' to force WEBrick)
=> Rails application starting on http://0.0.0.0:3000
...
** INT signal received.
Exiting

real	0m13.947s
user	0m11.327s
sys	0m0.892s

$ ruby -v
ruby 1.8.6 (2007-09-24 patchlevel 111) [universal-darwin9.0]
$ time ./script/server 
=> Booting Mongrel (use 'script/server webrick' to force WEBrick)
=> Rails application starting on http://0.0.0.0:3000
...
** INT signal received.
Exiting

real	0m6.273s
user	0m1.893s
sys	0m0.611s

With the same JRuby 1.1 (and without Charles recent speedup patch for jruby startup):

$ time jruby -S jetty_rails
2008-05-04 10:50:00.846::INFO:  Logging to STDERR via org.mortbay.log.StdErrLog
2008-05-04 10:50:01.013::INFO:  jetty-6.1.9
...
2008-05-04 10:50:02.987::INFO:  Started SelectChannelConnector@0.0.0.0:8080

real	0m7.035s
user	0m4.387s
sys	0m0.296s

As you can see, jetty_rails is very close to mongrel running in MRI, but please, don't take those numbers so seriously.

Jetty Rails should be ready to run any rails application (tell me otherwise!) with no dependencies on extra jars. All gems used by the application must be installed in your JRuby. I've made some simple benchmarks with JMeter and only one thread, firing 500 consecutive requests to a simple rails blog application. All requests pointed to '/posts' controller, and there was only one Post is the MySQL database.

The machine used to run all tests is a Intel Core2 Duo E4500 @ 2.20GHz, 2.0GB RAM, running Ubuntu 7.10, Ruby (MRI) 1.8.6 and JRuby 1.1.1. MRI tests were done using plain ruby activerecord-mysql-adapter and JRuby tests were done using activerecord-jdbcmysql-adapter.

Mongrel: 30.7 req/s
JMongrel: 19.1 req/s

Glassfish Gem: 17.5 req/s
dropping JVM warm time: 23.8 req/s

Jetty Rails: 18.2 req/s
dropping JVM warm time: 26.6 req/s

This is obviously a simple measure, just to feel how jetty-rails is going. But I'm very happy with the results. If we ignore the time that JVM takes to warm and JIT compile things, jetty-rails comes close to Mongrel! Impressive. I knew Jetty was always very fast, but I really didn't expect those results.

There is much more to do. Things from the roadmap I wanted to see working soon include:

• read warble.rb configuration files and register extra jars and public folders defined there;
• use any custom web.xml defined in config/web.xml (or config/web.erb.xml), following Wabler conventions.
• jetty_merb
• jetty_camping
• ...

The source code lives in GitHub. Feel free to fork, contribute, send patches and suggestions!

1. Can we stop calling everything that comes from Java with that damn J-at-start or with -let termination? ;)
2. I've stopped the processes (ctrl+c) as soon as I saw they were ready to respond to requests.

OK. I've jumped on the Git bandwagon, and to celebrate have made the ebay_shopping plugin (a ruby on rails library for eBay's shopping API) into a gem, hosted at Github. It'll take a few days before the rubyforge project is approved and loaded up, but you can still download it from github, or with a github clone.

Why turn it into a gem? Well, it was originally a plugin as that was the easiest and quickest way to do it at the time -- it was generated from a Rails application, after all. It also made things like getting the initial config (from a YAML file in the Rails config directory) a no-brainer, and meant I could use some of the ActiveSupport methods without thinking.

But over the past few weeks, I've been playing around with Merb, and decided these benefits are more than outweighed by the greater portability a gem brings. There's also the benefit of versioning and dependencies. Finally, with Rails edging away from plugins with 2.1, and the ease of gem generation using Dr Nic's newgem gem, there's really no reason to stay with the plugin approach. Enter, stage left, the ebay_shopping gem.

If you're already using the plugin, there's no hurry to change. If not, give the gem a try and let me know how it goes. Use is almost identical to the plugin. The only difference is with the initial configuration. You can still use the same YAML config file in your Rails config folder (if you're using Rails or Merb), you just need to set it up explictly in your environment.rb

EbayShopping::Request.config_params("#{RAILS_ROOT}/config/ebay.yml", RAILS_ENV)

Passing the RAILS_ENV as the second param just ensures it will use the correct environment settings from the config file, if you've got different ones for development, production, test, etc. If not, or if you don't tell it, it will just default to the production settings.

You can also (from the console, for example), set the inital configuration with a Hash

EbayShopping::Request.config_params({:app_id => "my_app_id", :default_site_id =>"3"})

The hash must provide the app_id you're given by ebay, and can optionally provide the ebay affiliate info and your preferred default country (e.g. the UK in the above one). This can be overridden in individual requests, or if you just leave it out it will default to ebay.com.

Enough waffle. Explore the code over at github. The documentation still needs tweaking, but the test suite and code comments should explain it all fairly well. Plus there are some use examples on the post about the original plugin, which still stand. Patches and forks welcome -- this is git after all we're talking about.

I saw for weeks that many Rails/Ruby related projects, including Ruby on Rails framework itself, are hosted on Github, a git repository hosting.

You can begin with a free Github account (you have a repository with 100mo quota).

First install git on your desktop/laptop :

1) On a Mac Intel, you can install Git by Mac ports : First assure you have the latest release of XCode, then reinstall Darwin Ports. To install git launch the following command :

sudo port install git-core

2) You can also install Git manually :

cd /usr/local/src
curl http://kernel.org/pub/software/scm/git/git-1.5.5.tar.gz > git-1.5.5.tar.gz
tar -xvzf git-1.5.5.tar.gz
cd git-1.5.5
make configure
./configure --prefix=/usr
sudo make install

3) On a Fedora just launch the command :

# yum install git

4) On a Debian just launch the command :

# apt-get install git-core

Signup (choose username / password / email and add a public key) on Github.com... then create your repository (specify at least the project name).

Github gives you the following instructions to push your project.

On your desktop, create your project, then push it to the remote repository by launching the following commands :

mkdir <project name>
cd <project name>
git init
touch README
git add README
git commit -m 'first commit'
git remote add origin git@github.com:<github username>/<project name>.git
git push origin master

Once this has been done , i copied the content of a Ruby on Rails application into my local repository, i committed the updates, then pushed everything to the remote repository:

cp -r ../<rails_app>/* .
git add Rakefile
git add app/
git add config/
git add db/
git add doc/
git add lib/
git add log/
git add public/
git add script/
git add test/
git add vendor/
git commit 'My project first import'
git push origin master

Now the skeleton of my RoR application has been pushed to the Github repository.

Explanations : Git is quite different from Subversion , it's a distributed SCM, which means you can work disconnected from the main repository (remote) by committing your changes locally.

The basic flow for the previous steps is the following :

The first time, you should create your git (local) repo (this create a .git in the root folder of your project):

# git init

Create a file for testing

# touch README

Then add it to your local repo :

# git add README

Commit to your local repo :

# git commit -m 'First commit'

Then we add the Github remote repository to our local repository as a remote server called “origin” (we say remote repo is "tracked")

# git add remote origin git@github.com:<username>/<project name>.git

Push our changes to the remote repository, in the main branch "master" (being the equivalent of 'trunk' in Subversion) :

# git push origin master

Show the branches (-r : only remote branches; -a : all branches) :

# git branch -a

* master

Suppose now another person (B) want to get a copy of (remote) repository :

# cd /path/to/my/workspace

# git clone git@github.com:<username>/<project name>.git

remote: Generating pack...
remote: Done counting 359 objects.
remote: Deltifying 359 objects...
Indexing 359 objects...te:
100% (359/359) doneemote: e done
remote: Total 359 (delta 94), reused 359 (delta 94)
100% (359/359) done
Resolving 94 deltas...
100% (94/94) done

# cd <project name>

Now this person (B) could update a file , then commit and push to the repository.

First do an update in a file from your project.

Show status :

# git status

# On branch master
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#
#       modified:   README
#
no changes added to commit (use "git add" and/or "git commit -a")

Add the changes in your local repo :

# git add README

# git status

# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   README
#

Commit this change to the local repo :

# git commit -a -m "Test update file"
Created commit 23f0d7f: Test update file
1 files changed, 1 insertions(+), 0 deletions(-)

Then push these changes to the remote repo :

# git push origin master

updating 'refs/heads/master'
from 80749cfe5dde07cedc7e50be420a266d8b698232
to   23f0d7fa999d2f4d0cbaed550677c9d07f70b8ca
Also local refs/remotes/origin/master
Generating pack...
Done counting 3 objects.
Deltifying 3 objects...
100% (3/3) done
Writing 3 objects...
100% (3/3) done
Total 3 (delta 0), reused 0 (delta 0)
refs/heads/master: 80749cfe5dde07cedc7e50be420a266d8b698232 -> 23f0d7fa999d2f4d0cbaed550677c9d07f70b8ca

Now the first person (A) should get its local mirror in sync with the remote repo : to do this, just launch the command :

# git pull

Updating 80749cf..23f0d7f
Fast forward
README |    1 +
1 files changed, 1 insertions(+), 0 deletions(-)

We saw the mechanism of Push/Pull, working in the main "master" branch of the repository.

Further readings show you how to manage conflicts, work with other repository branches than "master".

For Rails projects, you can use Capistrano for deployments combined with a Git SCM like Github.

Further readings :

Setting up a new remote git repository

Sourcemage's Git guide

Github guides

Deploying with Capistrano

We’re currently operating in stealth mode. We are looking for 1-3 full-time developers who are well versed in ROR who want to immerse themselves completely into our apps and help lead the development.

Ideally you should have strong experience developing with Rails, have successfully deployed a publicly accessible rails based website, have expertise in relational database design and optimization, experience with deploying and scaling production Rails applications, a detailed approach in design, coding and testing, familiarity with a broad range of web technologies including ajax, javascript, CSS, XML, open APIs.

Experience with social networking app implementations is a bonus.

Their idea of remote might be still be in the United States of America. Canada might be more remote than they have in mind. That said, if this sounds like your opportunity, there's no harm in asking, right?

Um-para-um, um-para-muitos, e muitos para muitos. Você indicar estes relacionamentos adicionanado os seguintes métodos aos seus models:

has_one,
has_many;
belongs_to;
has_and_belongs_to_many;
1) Relacionamento um-para-um

Este relacionamento poderá existir entre encomendas e faturas, por exemplo: para cada
encomenda há, no máximo, uma fatura. Nós declaramos por dizer isto em Rails:

class Order < ActiveRecord::Base
     has_one :invoice

class Invoice < ActiveRecord::Base

     belongs_to :order

2) Relacionamento um-para-muitos
Encomendas e linhas de itens têm um relacionamento um-para-muitos: pode haver qualquer um-para-muitos número de linhas de itens associados a uma encomenda particular. No Rails, para isso, temos o seguinte código:

class Order < ActiveRecord::Base
     has_many :line_items

class LineItem < ActiveRecord::Base
     belongs_to :order

3) Relacionamentos muitos-para-muitos

Podemos classificar os nossos produtos. Um produto pode pertencer a várias categorias,
e cada categoria pode conter vários produtos. Este é um exemplo de relacionamento de muitos-para-muitos, expresso no Rails da seguinte forma:

class Product < ActiveRecord::Base
     has_and_belongs_to_many :categories

class Category < ActiveRecord::Base
     has_and_belongs_to_many :products

As várias declarações de associações especificam o que se precisa para relacionamento entre tabelas. Elas acrescentam cada uma, uma série de métodos para o model, que ajudam a navegar entre objetos ligados. Vamos analisar estes em mais detalhe, no âmbito dos três tipos diferentes de intertable ligação. Iremos também olhar para cada um dos métodos injeta em sua classe host.

Why would someone even look at anything else, having such a great tool? Well, it turns out that our field is evolving really fast, and it's very hard to follow this current pace, even for the most dedicated and passionate ones. Currently there are several technologies evolving very fast, and they are meaningful to a lot of enterprise developers. The rise of the JVM's dynamic languages is crystal clear. Strong is also the growth of RESTFul web services. I'm personally very interested in both fields.

I'm currently using REST (lately with Jersey) for a lot of integrations between applications. The power it gives me is really nice, and I'm improving my developments each new month. I have also studied Groovy/Grails recently and really liked it. I wanna try JRuby on Rails sometime in the next weeks, to see what it offers and check how it compares to Grails. If you're a Java enterprise developer, I'm sure you're following the growth of these nitty things.

But where does Netbeans enter this talk? Well, Netbeans is doing a great job supporting these new technologies, and it's way ahead of Eclipse in this field right now. Have you seen how easily you can develop RESTFul web services with Netbeans 6.1? Jersey support is great, very productive. The support for JRuby on Rails and Grails is also present, in a much more advanced state than Eclipse's. Netbeans is doing a much better job than Eclipse regarding Web Services and JVM languages right now.

Swing development in Netbeans is very nice since version 5.0 (with the release of Matisse), and developing for mobile devices is also easier in Netbeans. Currently I don't develop swing nor mobile applications, so this doesn't really affect me.

However, I develop many RESTFul web services. And I wanna use more and more the JVM's dynamic languages. Ignoring Netbeans is not a clever idea right now.

I still find Eclipse's interface and editor much better than Netbeans's. I also know a lot of Eclipse's shortcuts and know very few in Netbeans. SWT is also faster than Swing, so Eclipse is faster than Netbeans. But considering what I said, I'm leaning towards the use of both IDEs at the same time. Since our machines are now much better equipped with RAM, I can have them open at the same time and also a couple of servers, with no memory shortage.

My Eclipse days are definitely not over, but now he's gonna divide my attention with Netbeans :) I hope I can become as productive with Netbeans as I am with Eclipse, even if it takes a few weeks. My first wish would be the Eclipse's Quick Fix (Ctrl + 1) avaiable in Netbeans. Even without it, I'm sure my usage of Netbeans will certainly grow, and think this competition between the IDEs is very good for us. Let Eclipse Ganymede come!

As such monkey patches are not easily maintainable and reusable between projects I decided to fork existing Oracle adapter and create my own ActiveRecord Oracle "enhanced" adapter where I will add all my enhancements.

Today I released first version (1.1.0) of Oracle enhanced adapter on RubyForge as well as source code is available at GitHub.

To install Oracle enhanced adapter execute:

sudo gem install activerecord-oracle_enhanced-adapter

To use it you need to use "oracle_enhanced" as the adapter name in database.yml configuration file instead of "oracle". In addition I recommend to create config/initializers/oracle_enhanced.rb file where to put any adapter configuration options that you can see below.

Initial version contains the following enhancements:

• Improved perfomance of schema dump methods when used on large data dictionaries
• Added LOB writing callback for sessions stored in database (see previous post)
• Added emulate_dates_by_column_name option

Set the option below and as a result columns with DATE in their name will be emulated as Date (and not as Time which is default for DATE columns in database)

ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true

• Added emulate_integers_by_column_name option

Set the option below and as a result number columns with ID at the end of column always will be emulated as Fixnum (useful if in legacy database column type is specified just as NUMBER without precision information which by default is mapped to BigDecimal Ruby type)

ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true

• Added emulate_booleans_from_strings option

Set the option below and as a result CHAR(1), VARCHAR2(1) columns or VARCHAR2 columns with FLAG or YN at the end of their name will be emulated as booleans (and "Y" and "N" will be used to store true and false values). This is useful for legacy databases where Rails default convention of NUMBER(1) for boolean values cannot be used (e.g. if you are using Oracle E-Business Suite where booleans are stored as "Y" and "N").

ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true

If you need to override how date, integer or boolean columns are identified then you can redefine class methods is_date_column?, is_integer_column? and is_boolean_column? definitions in OracleEnhancedAdapter class.

Please comment if you find these enhancements useful in your projects and also what other Oracle adapter enhancements you need in your Ruby on Rails on Oracle projects.

In the shadows and the steel, in dark and white of underground illumination, I am hiding. Back and out, dart to food, to water, to safety. The drama of a larger world goes on above, but I cannot countenance that. My own solemn lifestyle only allows for the smoke of metal sparking on metal, for the almost continual screech of breaks.

Awak banyak kali dapat buku RoR...keren kali awak tengok sampel mash-up nya gmaps, flickr, dkk....mantap kali tapi yg paling hot apalagi kalo bukan RAILS INTRANET dan RAILSPACE...ambon manise qren

Also present was Bob Claypole, he literally wrote the book on birding the Klamath River Valley.   The walk was organized by Sam Cuenca of the US Forest Service.  It was to observe International Migratory Bird Day.  I got to go and represent the Klamath Bird Observatory.

Shasta Valley, California, lies on the Shasta River draingage, a tributary of the larger Klamath River just to the north. This area is a few miles east of Yreka on I-5 and about 25 miles south of the Oregon border. On the way to the state-owned widlife area you pass through Montague with just over a 1000 residents and a large large metal cowboy statue in the city park. You go all the way to the end of California Route 3, and then keep going.

It's late in spring but we had a four-grebe day and over a dozen waterfowl species.  Horned and Eared Grebes on Streamboat Lake were in breeding plumage, those golden feathers adorning the birds' heads. 

Photo by Len Blumin.  Not taken in Shasta Valley.

The waterfowl ranged from Greater White-fronted Geese down in size to Bufflehead and Ruddy Ducks. 

Several breeding plumage Willets were working the lakeshore.  And there were two families of young Great-horned Owls.  Some were already able to fly.  I was most surprised by the presence of Great-tailed Grackle, now apparently a well-established breeding bird in that area.

Two of our more exciting big American birds were also in the valley.  We saw at least five different Sandhill Cranes.  The area is the southwestern most corner of the species' breeding range most years. Link to article on Sandhill Cranes in Shasta Valley. There were numerous White Pelicans, and these individuals are believed to be immatures not yet of breeding age.  I watched a trio of pelicans rise in ever-widening circles above Steamboat Lake.  They seemed to turn darker, but it was simply a clash of whites.  The white of Mount Shasta's snow-cone was so much brighter, lighter, even whiter than the pelicans'.  The soft feathers just couldn't match that glistening shine of ice slicked glaciers on California's northernmost volcano.

 See those tiny spots just left of the center at the top of the blue sky?  Huge white pelicans.  The peak behind the near ridge: Mt. Shasta,  It's over 14,000 feet high and gthe fifth tallest peak in California.  Shasta is more than 10,000 feet above the valley where we were birding.

Abundant but still a joy to watch: that inland denizen of marsh amidst drylands. Yellow-headed Blackbird.  Not only is he slightly bigger than the Red-winged and Brewer's, the Yellow-head has a voice...an accordion being played by a wrestler...the  death call of an air mattress...the squeak of a hinge last oiled in 1928...the exhalation of a fire hydrant filled with rusty nails.  It's raucous, its agonized, it's loud, it's incessant and it's as unforgettable as the male bird's yellow hood.  It made the boistrous calls of the grackle seem like a symphony.

It was a colorful day: White Pelican, Yellow-headed Blackbird, White-fronted Goose, Ruddy Duck, Yellow-rumped Warbler, Black-necked Stilt, Green-winged Teal and this Cinnamon Teal:

 BONUS PICTURE:

Yes, that's a white black-tailed (mule) deer. They were on a distant hillside but the only dark tint seemed to be on the deer's ears not the nominate tail.

Greater White-fronted Goose
Canada Goose
Gadwall
American Wigeon
Mallard
Cinnamon Teal
Northern Shoveler
Northern Pintail
Green-winged Teal
Ring-necked Duck
Lesser Scaup
Bufflehead
Ruddy Duck
Ring-necked Pheasant
Pied-billed Grebe
Horned Grebe
Eared Grebe
Western Grebe
American White Pelican
Double-crested Cormorant
Turkey Vulture
Osprey
Bald Eagle
Red-tailed Hawk
American Kestrel
Virginia Rail
American Coot
Sandhill Crane
Killdeer
Black-necked Stilt
Spotted Sandpiper
Willet
Ring-billed Gull
California Gull
Forster's Tern
Mourning Dove
Great Horned Owl
Western Kingbird
Black-billed Magpie
Common Raven
Tree Swallow
Northern Rough-winged Swallow
Barn Swallow
Oak Titmouse
Bushtit
House Wren
European Starling
Yellow-rumped Warbler (Audubon's)
Common Yellowthroat
Wilson's Warbler
Savannah Sparrow
Song Sparrow
Lincoln's Sparrow
Red-winged Blackbird
Western Meadowlark
Yellow-headed Blackbird
Brewer's Blackbird
Great-tailed Grackle
Brown-headed Cowbird
 
 Total species reported: 59

• By Ezra Zygmuntowicz, Bruce A. Tate
• First Edition May 2008 (est.)
• Publisher: Pragmatic Bookshelf
• Pages: 304
• ISBN 10: 0-9787392-0-5 | ISBN 13: 9780978739201

This book will help you sleep better at night, knowing that your application can handle anything that gets thrown at it. Come away with the knowledge of how to optimize your Rails projects for speed and concurrency. You'll take advantage of advanced caching techniques and become an expert in lighttpd and Apache server environments.

• By Mike Clark
• First Edition May 2008 (est.)
• Publisher: Pragmatic Bookshelf
• Pages: 420
• ISBN 10: 0-9787392-2-1 | ISBN 13: 9780978739225

With the help of a community of Rails chefs in the kitchen, here are 72 new ways to kick your Rails apps up a notch. Advanced Rails Recipes is a collection of practical recipes for spicing up your web application without a lot of prep and cleanup. You'll learn how the pros have solved the tough problems using the most up-to-date Rails techniques (including Rails 2.0 features) so you can deliver your stunning web app quicker and easier.

After a database migration, a schema dump takes place. This allows fast recreation of databases without having to go through every single migration. The problem with this is that any seed data added during the migrations is not added back in when doing a db:reset. This can be solved by having a similar function to Schema Dumper.

Here are the seed data tasks (you probably want to add these into the db namespace):

[sourcecode language="ruby"]
namespace :seed_data do
desc 'Load schema seed data'
task :load => :environment do
puts "== Loading dumped seed data"
config = ActiveRecord::Base.configurations[RAILS_ENV || 'development']
ActiveRecord::Base.establish_connection(config)
require 'active_record/fixtures'
Dir.glob(RAILS_ROOT + '/db/seed_data/global/*.yml').each do |file|
Fixtures.create_fixtures(RAILS_ROOT + '/db/seed_data/global', File.basename(file, '.*'))
end
end

desc 'Save schema seed datae'
task :dump => :environment do
config = ActiveRecord::Base.configurations[RAILS_ENV || 'development']
ActiveRecord::Base.establish_connection(config)
Database::SeedDataDumper.dump(ActiveRecord::Base.connection)
end
end
[/sourcecode]

You'll need the SeedDataDumper class:

[sourcecode language='ruby']
module Database
class SeedDataDumper

def self.dump(connection)
new(connection).dump()
true
end

def dump()
@connection.tables.each do |table|
if @connection.select_all("DESCRIBE #{table}").inject(false) { |b, col| b || (col["Field"]=="came_from_migration") }
data = @connection.select_all("SELECT * FROM #{table} WHERE came_from_migration IS NOT NULL")
if !data.empty?
outfile = File.new("#{@folder}/#{table}.yml", "w")
header(outfile)
i = "0"
outfile.write data.inject({}) { |hash, record|
hash["#{table}_#{i.succ!}"] = record
hash
}.to_yaml
footer(outfile)
end
end
end
end

private
def initialize(connection)
@connection = connection
@folder = "#{RAILS_ROOT}/db/seed_data"
puts "== Dumping seed data"
end

def header(stream)
stream.puts < # This file is auto-generated from all the current "came_from_migration" rows in the selected
# database. It generates a yaml file per table which can be loaded in again using fixtures.
HEADER
end

def footer(stream)
stream
end

end
end
[/sourcecode]

Remember to put the following line at the end of your db:migrate task:

[sourcecode language="ruby"]
Rake::Task["db:seed_data:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
[/sourcecode]

1. Fixtures#create_fixtures deletes data - Whoops! After looking at the source code, create_fixtures effectively drops all the data in the table it is just about to populate. Obviously this isn't very useful if you want to use a migration on any table that isn't empty.
2. Related data - Migrations in Rails 2 have a nifty feature allowing you to create inter-related table rows by using named data items. The methodology outlined in Part 1 doesn't load all the yaml files into the migration and then run them, instead it runs them one at a time meaning (and with no model class) so Rails is unable to resolve the relationships between rows.

[sourcecode language="ruby"]
monkeys:
george:
name: George the Monkey
pirate: reginald
fruits: apple, orange, grape

fruits:
apple:
name: apple

orange:
name: orange

grape:
name: grape
[/sourcecode]

This naming convention follows the ideas behind migration naming convention and doesn't stop you having more than one seed file per migration (obviously of unrelated data) e.g. 006_add_tables_and_chairs.yml

Temporary work around

For the time being (until we extend the yaml parser) we have written a slightly different seed data function for our migration files This allows us to seed a row into the database, read its insertion ID and then reference that row object in subsequent inserts.

Conclusion

We still think that Fixtures provides a pretty good way of introducing structure data into our tables, but just needs a little bit more work before it plays nicely with migrations. We have also found the time to start writing the schema dump/load equivalents for seed data (when creating database from schemas, i.e. in production). These methods are just being finished and tested and we will post them up here in the next couple of days.

The acts_as_solr Rails plugin allows you to interface with the Solr search server. It makes indexing your models extremely simple, usually just a single line in your model file is needed.

Acts_as_solr didn't seem to provide a simple way to have Solr index my fields so that I could search by substring. After a lot of pain I figured it out.

Solr has a few different types of tokenizers which it uses to split up data before it indexes it. If you look in Solr's schema.xml file you can see the default tokenizer for a "text" field is solr.WhitespaceTokenizerFactory. This allows you to search by individual words (or anything delimited by whitespace) from your text, but not by a substring.

To be able to search by substring you must use the NGramTokenizerFactory. The NGramTokenizer indexes all possible substrings of your text (within the limits you set). So if the text is "sam" you'd end up with the following strings indexed: s, sa, sam, a, am, m.

It takes two parameters. Minimum and maximum gram size. These specify the shortest and longest substrings, respectively, that Solr will index.

Here's an example of how to use the NGramTokenizerFactory in your schema.xml:

[sourcecode language='xml']










[/sourcecode]

Be sure to put this in the correct schema.xml. Acts_as_solr ships with two schema.xml files. The correct one is at this path: vendor/plugins/acts_as_solr/solr/solr/conf/schema.xml. After you add this to your schema.xml you will need to restart and reindex the solr server: rake solr:stop; rake solr:start; rake solr:reindex

To see how it actually works here an excerpt from Lucene's NGramTokenizer class.

[sourcecode language='java']
public final Token next() throws IOException {
if (!started) {
started = true;
gramSize = minGram;
char[] chars = new char[1024];
input.read(chars);
inStr = new String(chars).trim(); // remove any trailing empty strings
inLen = inStr.length();
}

if (pos+gramSize > inLen) { // if we hit the end of the string
pos = 0; // reset to beginning of string
gramSize++; // increase n-gram size
if (gramSize > maxGram) // we are done
return null;
if (pos+gramSize > inLen)
return null;
}
String gram = inStr.substring(pos, pos+gramSize);
int oldPos = pos;
pos++;
return new Token(gram, oldPos, oldPos+gramSize);
}
[/sourcecode]

As you can see it first iterates over the string creating tokens (grams) of the minimum length. It then increments the token size and iterates again. So in the case of "sam", it would create in this order: s, a, m, sa, am, sam.

There is also an EdgeNGramTokenizerFactory class which only indexes substrings at either the beginning or end of a string. It takes an extra argument of side="front" or side="back".

learining rails is a great expirience but now dealing with it professionaly is much more interesting.You come to know a new aspect of rails every day when  you serach about it,its getting bigger and better day by day.

i recently completed my new project which manages my college dept details regarding nearly everything from teachers,students,staff to placement and seminars.

it also generates dynamic reports according to  your search criteria and gives option even to download it in excel format.i have even added an ajax based QUIZ.

i have 12 modules in my project they are as follows:-

1-About Us-it has info regarding my college

2-People

e

Os livros estão novos, se interessar a alguém posso tirar uma foto deles. Comprei faz pouco tempo.

Preço: R$40,00 cada

E-mail: fmarassatto@gmail.com

Moro em Itatiba, interior de São Paulo.

Summary: Learn more about DogOnRails from the project lead. What's DogOnRails? DogOnRails is an open source Ruby on Rails implementation of the WifiDog 1.0 protocol designed to be used with a customized version of the ROBIN software. DogOnRails acts as the dashboard for FreeTheNet.ca - a Vancouver Open Network Initiative Cooperative (VONIC) project connecting Canada one block at a time using Open-Mesh enabled wireless routers.

About Joe Bowser:
Joe Bowser is one of the co-founders of the Vancouver Open Network Initiatives Cooperative (VONIC), and FreeTheNet.ca, a Community Wireless Mesh Network in Vancouver, BC. Joe's current day job is working at Nitobi Software, where he works with Javascript, Ruby on Rails, and other open source technologies. Joe has also taken very active roles in other not-for-profits, such as volunteering at Free Geek Vancouver, and Spartacus Books, and is committed to Open Access to information and the Free Software movement.

---
Volunteer as a speaker for upcoming meetups. Add your talk to the wiki. Thanks!

Looking for Ruby/Rails talent? Interested in pitching your startup? We can help!

Here is how it works: Pay everyone a beer/drink at the Ruby Pub Nite (usually 10-20) and in return step on a chair and get your 3-5 minutes of fame to tell us all about your startup, job openings, etc. Win-Win for everybody! Cheers!
---
More info and sign-up at the Vancouver Ruby/Rails June meetup event page.
---
Questions? Comments? Send them along to the Vancouver.rb Mailing List/Forum. Thanks!