If a helper corresponds to a specific controller, you should put it in the corresponding helper file. For example, helpers for the Pages controller generally go in app/helpers/pages.helper.rb.

If the helper is going to be used on all a sites pages then the helper file to use is app/helpers/application.helper.rb.

In the helper file:

def title
base_title = "Ruby on Rails Tutorial Sample App"
if @title.nil?
base_title
else
"#{base_title} | #{@title}"
end
end


In the view:
<%= title %>

Create a new application at Heroku
$ heroku create

Deploy your app
$ git push heroku master

Open your app
$ heroku open

Rename your subdomain
heroku rename appnamehere

First-time system setup

Do these steps once per computer.

Head over to Installing Git section of Pro Git and install Git.

$ git config --global user.name "Your Name"
$ git config --global user.email youremail@example.com
$ git config --global core.editor "mate -w"

(this last line is if you’re using textmate)

Setting up a NEW Repository for your App

Generally you will setup a repository for each application you create.

1. Initalize the repository

$ git init
Initialized empty Git repository in /Users/username/rails_apps/first_app/.git/

2. Add the project files to the repository (but ignore some first!)

By default Git tracks the changes of all files, but there are some we don’t want to track. For example, the log files. We ignore files by including a file named .gitignore in the Rails root directory. Generate this file using your text editor and here’s a sample of what you might put in it.

log/*.log
tmp/*
tmp/**/*
doc/api
doc/app
db/*.sqlite3
*.swp
*~
.DS_STORE

Now we may add files to Git.
$ git add .

The dot ‘.’ represents the current directory and Git is smart enough to add the files recursively so it automatically adds all subdirectories. This places the projects files in a staging area. You can see what files are in the staging area using the status command.
$ git status

3. Committing files to the repository

To tell Git you want to keep the changes in the staging area, use the commit command.
$ git commit -m "Initial commit"

The -m lets you add a message for the commit.

Remember, Git commits are local, recorded only on the machine on which the commits occur.

To push the changes to a remote repository you must use git push.

Branch, Edit, Commit, Merge

When making changes to an application use this process.

1. Checkout a Branch


$ git checkout master
$ git checkout -b 'branch name'

Notice the -b flag for checking out a branch. The first line just ensures we are branching from the master.

git branch will list all the local branches, with an asterix identifying which branch we’re currently on.

2. Edit

Edit your files as required.

3. Commit

If you’ve added new files make sure you use git add . prior to doing a commit. Otherwise you may use the -a flag with your commit if you’ve modified existing files.
$ git commit -a -m "comment goes here"


4. Merge

When finished making changes, you merge these back to your master branch.
$ git checkout master
Switched to branch 'master'
$ git merge modify-README

Change modify-README to the name of your branch.
Afterwards you can tidy up your branches by deleting the topic branch.
$git branch -d modify-README

Push your changes to a remote repository

Use the push command
$ git push

Strings are surrounded in quotes. For example, "David" is a string.

A complete list of Ruby string methods is here.

.reverse
"David".reverse
>> "divaD"

.length
"David".length
>> 5

.strip
Removes white space around a string.
"David ".strip
>> "David"

multiplication
"David" * 5
>> "DavidDavidDavidDavidDavid"

Converting Object Types

.to_s – converts to strings
.to_i – converts to integers
.to_a – converts to arrays

Arrays / Lists

Use brackets [].
[12, 47, 35]

.max
[12, 47, 35].max
>> 47

Hash / Dictionary / Associative Array

A hash is when you want to associate one thing with something else, like a dictionary. These are called Key, Value pairs.
Hashes use curly braces {}.

food["Fish"] = :yum
food["Dog"] = :yuck
food["Beef"] = :delicious

food
>> {"Fish" => :yum, "Dog" => :yuck, "Beef" => :delicious}
rating
food.keys
>> ["Fish", "Dog", "Beef"]


Blocks

Using the above example of food, you may use a block like the following to tally your results.

books.values.each { |rate| ratings[rate] += 1 }
>> [:yum, :delicious, :yuck]

ratings
>> {:yum => 1, :yuck => 1, :delicious => 1}


Another example of using a block:
5.times {print "Yes!"}
>> Yes!Yes!Yes!Yes!Yes!

Classes

String, Array, Hash are all examples of Classes.

Creating a class
class BlogEntry
attr_accessor :title, :time, :fulltext, :mood
end

attr_accessor is how you define variables, or in this case attributes attached to a class.

Let’s start a new entry.
entry = BlogEntry.new
entry.title = "Hello world!"
entry.fulltext = "Yes this is my first post!"
entry.mood = :sick
entry.time = Time.now


The initalize Method
Using the initalize method you won’t have to type the time every post.

class BlogEntry
def initalize( title, mood, fulltext )
@time = Time.now
@title, @mood, @fulltext = title, mood, fulltext
end
end

Important things to notice
Outside the class we use accessors: entry.time = Time.now. But inside we use instance variables: @time = Time.now.