Scott: /* Application Setup */

2011-02-02T19:28:32Z

Application Setup

New page

== Installation ==
* Install ruby and rubygems as you would any other package.
* Use gems to install rails:
<pre>
sudo gem update
sudo gem install rails
</pre>
* To match a specific version:
<pre>
gem install rails -v 2.3.5
</pre>
* show installed gems:
<pre>
gem list
</pre>
* make links to /var/lib/gems/1.8/bin binaries in /usr/local/bin

== More Installation Wisdom ==
I wanted to be able to develop this on my macbook too. I installed ruby and rubygems from source. I ended up getting version 1.3.1 of rubygems and 2.2.2 of rails, which was higher than on my Ubuntu Intrepid machine. So I had to update rubygems beyond the official intrepid version using this:
<pre>
sudo gem install rubygems-update
cd /var/lib/gems/1.8/bin
sudo ./update_rubygems
</pre>

Now I have to reinstall the latest gems all over again:
<pre>
sudo gem install rails composite_primary_keys
</pre>

There were also problems because rails has dropped default support for mysql:
<pre>
sudo apt-get install ruby1.8-dev libmysqlclient15-dev
sudo gem install mysql
</pre>

Edits to <code>config/environment.rb</code>:
* comment out this line: <code>config.time_zone = 'UTC'</code>
* add this line: <code>require 'composite_primary_keys'</code>

Copied old <code>config/database.yml</code> to new project

== Reference ==
* Ruby on Rails web site: http://www.rubyonrails.com/
* Documentation: http://api.rubyonrails.org/,
* Wiki: http://wiki.rubyonrails.com/

== Application Setup ==
* Create rails app:
<pre>
rails -d mysql cookbook
</pre>
This creates a big directory containing all code for the project.

* Login to mysql as root and create mysql databases:
<pre>
mysql> create database cookbook_dev;
mysql> create database cookbook_test;
mysql> create database cookbook_prod;
</pre>

* Create a mysql user account and give it rights to the databases:
<pre>
mysql> grant all privileges on cookbook_dev.* to 'rails_user'@'localhost' identified by 'r8!lz';
mysql> grant all privileges on cookbook_test.* to 'rails_user'@'localhost' identified by 'r8!lz';
mysql> grant all privileges on cookbook_prod.* to 'rails_user'@'localhost' identified by 'r8!lz';
</pre>

* Define tables. Edit a file called create-mysql-db.sql:
<pre>
drop table if exists 'chapters';
create table chapters (
id int not null auto_increment,
title varchar(255) not null,
sort_order int not null default 0,
primary key (id)
) type=innodb;

drop table if exists 'recipes';
create table recipes (
id int not null auto_increment,
chapter_id int not null,
title varchar(255) not null,
problem text not null,
solution text not null,
discussion text not null,
see_also text null,
sort_order int not null default 0,
primary key (id, chapter_id, title),
foreign key (chapter_id) references chapters(id)
) type=innodb;

drop table if exists 'tags';
create table tags (
id int not null auto_increment,
name varchar(80) not null,
primary key (id)
) type=innodb;

drop table if exists 'recipes_tags';
create table recipes_tags (
recipe_id int not null,
tag_id int not null,
primary key (recipe_id, tag_id),
foreign key (recipe_id) references recipes(id),
foreign key (tag_id) references tags(id)
) type=innodb;
</pre>

* Create tables:
<pre>
$ mysql cookbook_dev -u rails_user -p < create-mysql-db.sql
$ mysql cookbook_test -u rails_user -p < create-mysql-db.sql
$ mysql cookbook_prod -u rails_user -p < create-mysql-db.sql
</pre>

* Edit <code>config/database.yml</code> to have the right username/password for each database (double-check database names too).

== Model ==
To create an object that will be linked to a database table (e.g. users):
<pre>
ruby script/generate model <object/table name (singular form)>
</pre>

For example:
<pre>
ruby script/generate model user
</pre>

This creates a file called <code>app/models/user.rb</code>, which defines a User ActiveRecord class. Edit this file to add table relationships. For example, we might have <code>cookbook/app/models/chapter.rb</code>:
<source lang="rails">
class Chapter < ActiveRecord::Base
has_many :recipes
end
</source>

Other relationship functions include <code>belongs_to</code> and <code>has_and_belongs_to_many</code>.

Find example:
<source lang="rails">
found_user = User.find(userid)
found_user = User.find(:first, :conditions => ["email = ?", email])
</source>

== Controller ==
To control an object's behavior:
<pre>
ruby script/generate controller <object (single form)> <list of actions>
</pre>
For example:
<pre>
ruby script/generate controller user add delete login logout
</pre>
This command creates a file <code>app/controllers/user_controller.rb</code>, which defines a class <code>UserController</code>. The class defines four stub methods: <code>add</code>, <code>delete</code>, <code>login</code>, and <code>logout</code>.

=== Logging from a controller ===
<source lang="rails">
class HomeController < ActionController::Base
def index
logger.info 'informational message'
end
end
</source>
This will show up in the server log. Log levels are debug, info, warn, error, and fatal. In production, debug entries are omitted.

== View ==
The view files are created automatically for each action specified at controller creation. The same command that created the <code>UserController</code> class above also created four files in <code>app/views/user/</code>: <code>add.rhtml</code>, <code>delete.rhtml</code>, <code>login.rhtml</code>, and <code>logout.rhtml</code>. A user accesses the view by opening <code>http://www.example.com/my_app/add</code>.

Info on <code>select</code> vs <code>select_tag</code> vs <code>collection_select</code>: http://shiningthrough.co.uk/blog/show/6

=== Editing .rhtml files ===
* Use <code><% ... %></code> to hold ruby code that should be processed.
* Use <code><%= ... %></code> to also print the output of the code.
* Comments:
<source lang="rails">
<%
=begin
This style will work with scriplets too <%= now.broken.function(foo) %>
=end
%>

<% if false %>
so will this style <%= now.broken.function(foo) %>
<% end %>
</source>

=== Access to data ===
* The view can access the controller's instance variables like <code>@name</code>.
* The view can't access any of the controller's methods, class variables (<code>@@my_class_name</code>), or constants.
* The view can access global constants defined in <code>config/environment.rb</code>.

=== Layouts/Templates ===
* To apply a layout to every page in your web application, create a file called <code>app/views/layouts/application.rhtml</code>. It should look something like this:
<source lang="rails">
<html><head><title>My Website</title></head>
<body>
<%= @content_for_layout %>
</body></html>
</source>
* Make a view-specific template by creating <code>app/views/layouts/my_view.rhtml</code>.
* Layouts can access all of the same data that views can.

Rails Basics - Revision history

Scott: /* Application Setup */