Fortunately Rails provides us with a mailer generator to set up the basics:

ruby script/generate mailer MyMailer

You can of course call it as you like it to fit your application. But for this HOWTO let’s stick to MyMailer. As you have noticed, Rails created some files for us:

exists  app/models/
create  app/views/my_mailer
exists  test/unit/
create  test/fixtures/my_mailer
create  app/models/my_mailer.rb
create  test/unit/my_mailer_test.rb

At first, we need to edit app/models/my_mailer.rb and add the following code:

def mail(recipient, subject, bodyText)
  from "no-reply@mydomain.com"
  recipients recipient
  subject subject
  body :bodyText => bodyText
end

Notice: make sure you don’t use @from or @body – you maybe won’t get any error but it simply won’t work!
This is the function that will be called when we want to send a mail. You can also use default values (like for the from address) for subject and body if you like. But we want to provide our application with a form to enter subject and body and to select some recipients (so we have a mass mailer, basically). Let’s edit the mail template – this is the body of our mail message. It resides in app/views/my_mailer and we call it mail.html.erb (we have to create that). Then we put in:

<%= @bodyText %>

At the moment, the body text is sufficient, but you can also add a salutation, footer line or whatever you want to be sent alongside the stuff the user puts in the body field in the mail sending form. Here is the code you have to put in the controller which is supposed to send the mails (I used admin):

def sendEmail
  params[:recipients].each do |r|
  MyMailer::deliver_mail(r, params[:subject], params[:body])
end

The each-loop allows for stuffing multiple recipients into our mail sending function. But we need a form to select these users and provide a subject and body field. So you have to create a view (e.g. admin/sendMyMail.html.erb) and put in something like that:

<% form_tag '/admin/sendEmail' do %>
<label>Subject:</label><br />
<input type="text" name="subject" /><br /><br />
<label>Recipients:</label><br />
<select name="recipients[]" multiple>
<% Recipient.find(:all).each do |r| %>
<option value="<%= r.mail %>"><%= r.firstname + ' ' + r.lastname %></option>
<% end %>
</select>
<br /><br />
<label>Message:</label><br />
<textarea name="body"></textarea>
<br /><br />
<input type="submit" value="send 'em" />
<% end %>

I used a model Recipient here, you can of course use any model you want, extract the (rather ugly) database querying and put it in a helper etc.

Related posts

• Quick and Dirty Guide to your 1st Rails app – Part #1 (2)
• ActiveScaffold: How to get started (2)
• The NumberHelper in Rails (0)
• Symfony: How to get data from session into form (1)
• SVN: A quick HOWTO (0)

When using SVN for the first time, I followed a tutorial on the net but it was quite misleading and thus I had quite some trouble with checking in and out.

Let’s say we have an application that resides under /var/www/myApp/ and we have a SVN repository over at www.mydomain.com/svn/myAPP (you can create that via svnadmin create myAPP in the svn/ directory).

OK, at first, we have to check out the empty repo to a directory (I use /home/joe/myAPP here):

svn co http://www.mydomain.com/svn/myAPP /home/joe/myAPP

Then, we jump into our temporary repo and create the necessary directories:

cd /home/joe/myAPP
mkdir tags branches

Done? Good. Let’s copy our application to the trunk/ directory:

cp /var/www/myAPP trunk -a

Now we can add our 3 folders to the SVN repository (in fact, we only mark them for addition, they are added once we commit our changes by checking in):

svn add trunk branches tags

trunk, branches and tags directories are now registered as part of our SVN repo. But hey! Let’s assume we have two folders (private and logs) which we don’t want to be updated when checking in changes to our repository. We can now set ignore rules to avoid them being checked in:

svn propedit svn:ignore .

An editor will open – this can be VIM, nano or whatever you have set as your shells default editor. Enter the following lines and save+close:

trunk/private
trunk/logs

You can also set single files or wildcard specs to be ignored:

trunk/log/*.log
trunk/private/*
trunk/private/myDocument.txt

Once you’re done, let’s check in our changes to the repo:

svn ci

Now you can enter a message (for the first time I use “initial commit”), save+close and you will notice that SVN works on your changes and gives back a revision number. This is your current version.

Once you’re done, I’d suggest making an update, removing our repo checkout and checking out only trunk/ since you won’t need tags and branches when working locally:

svn up
cd ..
rm -rf myAPP
svn co http://www.mydomain.com/svn/myAPP/trunk myAPP

Now you’re set!

Related posts

• Symfony: How to get data from session into form (1)
• Quick and Dirty Guide to your 1st Rails app – Part #1 (2)
• Mailer HOWTO for Rails (2)
• ActiveScaffold: How to get started (2)

First, install rubygems via your favourite package manager or head over to www.rubyonrails.org, grab the package and follow the instructions. Then install some gems you need (I assume you like mySQL so I install the mysql gem for DB connection but you can of course also go with postgreSQL or sqlite).

Notice: this guide is written for Linux!

Make sure you have the development libs of your favourite database (mySQL, …) installed or else you will run into trouble when installing the gems.

sudo gem install rails mysql rake railroad

This will install rails, the mysql connector, the rails make tool rake (which is needed for several tasks from migrating to stuff to your database, inserting prepared data into it or updating your javascripts and much more).

Now you’re set to pick a folder (I tend to make a rails/ folder in my home dir) for your rails apps:

mkdir /home/<myusername>/rails

and create your first rails app:

cd /home/<myusername>/rails/
rails -d mysql myFirstApp
cd myFirstApp

You will notice that rails has created some folder for you. The ones that concern us at the moment are:

app/
config/
db/
public/
script/
vendor/

In app/ all the necessary controllers, models and views as well as partials live (we’ll get to that later), config/ contains configuration files and environment-specific extra configuration as well as the database schema file, db/ contains the database migrations we need to spice up our database, public/ contains stuff like javascripts, images, stylesheets etc. and vendor/ is the place where we can put our gems and plugins.

An especially important directory is script/ which contains our generators (which provide us with means of creating functionality, models etc.) and the launcher for Rails’ built-in webserver.

Important hint: DO NOT delete these folders unless you know what you are doing – it WILL break your app!

I know this is a bit hefty at the moment, but trust me – it will become clear once we work with the files and folders (I will introduce some of the concepts of Model-View-Controller (MVC), the Rails concepts and basic ideas and so on throughout this tutorial).

Let’s jump right into the action and take a look at our database config. Start by editing config/database.yml :

After a clean install, it will look like this:


development:
adapter: mysql
encoding: utf8
reconnect: false
database: myFirstApp_development
pool: 5
username: root
password:
socket: /var/run/mysqld/mysqld.sock


# 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: mysql
encoding: utf8
reconnect: false
database: myFirstApp_test
pool: 5
username: root
password:
socket: /var/run/mysqld/mysqld.sock


production:
adapter: mysql
encoding: utf8
reconnect: false
database: myFirstApp_production
pool: 5
username: root
password:
socket: /var/run/mysqld/mysqld.sock

Since I take it you know how to create a database and how mySQL works – just fill in the appropriate data in the fields and save it. You may change the database names but I strongly recommend you to to keep the syntax of dbname_test, dbname_development and so on.

Done? Great! Now let’s tell rake to create our databases:

rake db:create:all

If you take a look at your mySQL server (e.g. via phpMyAdmin) you see that rake has created the databases for us. You may now fire up the server:

ruby script/server

and head on to http://localhost:3000 to see a RoR placeholder there. So far so good. Now remove the index.html page from public/ since it is just the placeholder page and reload your browser window – ooops! An error has occured. Get used to these nifty error messages from RoR – you will see many of them, trust me

But no hassle – we will fix this immediately. The cause of this error is that we have killed the placeholder but our Rails app doesn’t know where to go now. So we have to tell it the right way to a controller (which we don’t have yet) so myFirstApp can display something. For this, we have to create a controller:

ruby script/generate controller welcome

Now you will see that Rails creates some files:

exists  app/controllers/
exists  app/helpers/
create  app/views/welcome
exists  test/functional/
create  test/unit/helpers/
create  app/controllers/welcome_controller.rb
create  test/functional/welcome_controller_test.rb
create  app/helpers/welcome_helper.rb
create  test/unit/helpers/welcome_helper_test.rb

exists means that Rails has found out that the directory already exists so it won’t be created, created means that Rails has created a file or folder.

In app/, Rails has created a controller (where our programming goes), a model (which basically is our database table), a view folder (where we can put HTML files to display what the controller pulls from the model) and a helpers folder. We will discuss these later, just let’s stay straight and take a look at our controller:

class WelcomeController < ApplicationController
end

Not much here, eh? So let’s put an index action there which controls what is displayed when one calls http://localhost:3000/welcome/ in the browser:

def index
@data = "Hello World..."
end

Notice: If you have not taken a look at Ruby and its reference – this will definitely a good time to do so or else you won’t be capable to code stuff for your application!

Ok, what is this? @data is a variable which contains the string “Hello World…”. This variable has been defined inside the index function of our controller which means that in our index view, we can use it. But – guess what? Right, we have no index view yet. So let’s create it. That’s simple: just put a file named view.html.erb in our app/views/welcome/ folder. There, just put one line:

<%= @data %>

What the heck is this? Tataa… it’s ruby code! <%= basically is the same as <?php echo or <?php print - it puts out the data our variable is holding to the browser. So when you call our brand new index view via

http://localhost:3000/welcome/

you will see that “Hello World…” is displayed. For now, we want that our welcome controller view is called whenever someone navigates to the root of our application by entering http://localhost:3000 – we can achieve this via Rails’ routing configuration in config/routes.rb:

When you open this file in your editor, you notice a lot of stuff that’s already there. At the moment, only the line

# map.root :controller => "welcome"

is interesting. Simply remove the # to uncomment it, save the file and restart the server (CTRL+C in the shell and then start it up again). That’s it – welcome is now our main controller! And that’s it for our first lesson – you have created your first Rails application!

Related posts

• Rails: Extracting fixtures from databases (0)
• Mailer HOWTO for Rails (2)
• ActiveScaffold: How to get started (2)
• The NumberHelper in Rails (0)
• Symfony: How to get data from session into form (1)

Some prerequisites:
I use Rails 2.3.4 at the time this is posted and my gem list shows:

actionmailer (2.3.4)
actionpack (2.3.4)
activerecord (2.3.4)
activeresource (2.3.4)
activesupport (2.3.4)
flickraw (0.7.1)
json (1.1.9)
locale (2.0.4)
locale_rails (2.0.4)
mime-types (1.16)
mysql (2.8.1)
rack (1.0.0)
railroad (0.5.0)
rails (2.3.4)
rake (0.8.7)
thoughtbot-paperclip (2.3.1)

Installation:
To install AS, open a shell and type:
ruby script/plugin install git://github.com/activescaffold/active_scaffold.git
Installs AS and all the necessary stuff
ruby script/plugin install git://github.com/rails/in_place_editing.git
Ooops, in place editing was missing – so let’s install it.
ruby script/plugin install --force git://github.com/lackac/render_component.git -r rails-edge'
Ooops again, render_component was taken out of Rails so subforms wouldn’t work – let’s get around this by installing lackac’s plugin (thanks!)

OK, basically, you are set. What now?
The ActiveScaffold website (www.activescaffold.com) and especially their API docs are your bible. So read them, re-read them and re-re-read them while building stuff with AS – you will need the (rudimentary) tipps included there.
Ok, now let’s start with integrating AS into our app. Let’s say you have a basic application which already has a master layout. Put this tag into the of your layout:

<%= active_scaffold_includes %>

It includes all the magic needed for AS. To continue, you should have a resource we can work on, in this case I created a resource named “customer” to store some customer info in it and work on it with AS:

ruby script/generate resource customer name:string phone:string email:string description:string is_active:boolean

Migrate the data now:

rake db:migrate

Edit your customers_controller.rb in app/controllers and put

active_scaffold :customer do |config|
end

right after

class CustomerController < ApplicationController

to make AS aware that it should take care of our customers. Now open config/routes.rb and add :active_scaffold => true right after the customer resource. When you start your server and call /customers, you now should see AS in action. Congratulations, this was the first part

Related posts

• Rails: Integrate FCKEditor with ActiveScaffold (0)
• Quick and Dirty Guide to your 1st Rails app – Part #1 (2)
• Must-have plugins for Rails (0)
• Mailer HOWTO for Rails (2)
• The NumberHelper in Rails (0)

In standard PHP, you would have put <?php echo $_SESSION['userId'] ?> and be set, but in Symfony, you have to put sfContext::getInstance()->getUser()->getAttribute('...'); in your action to get it to work.

Related posts

• Symfony: Allowing extra field in validated forms (0)
• SVN: A quick HOWTO (0)
• Quick and Dirty Guide to your 1st Rails app – Part #1 (2)
• Mailer HOWTO for Rails (2)
• ActiveScaffold: How to get started (2)