Vision Master Designs » Ruby on Rails

Tutorial : Introduction to AJAX in Ruby on Rails with Prototype, Script.aculo.us

Michael — Sat, 04 Oct 2008 16:40:43 +0000

Heya,
After a long time I had the time to update my blog. I have been working on my project presentation for the past 2 weeks. The entire presentation was developed in Flash CS3 coded in ActionScript 3. It was ages since I had used Flash and I was quite astonished how it had changed over the years. I`ll be soon posting some tutorials on Flash, so do keep an eye out

Anyways apart from being a bit off-topic, This tutorial deals with AJAX implementation in Ruby on Rails 2. While I was learning RoR, I had lot of issues of properly having AJAX implementation in my projects. This tuorial is for those people out there.

In this tutorial, I`ll just show some very simple Script.aculo.us Animation Implementations in RoR.
View Demo

Introduction

First off, if you followed my RoR tutorials, you should know that RoR has AJAX support built in to it. It uses the Prototype Javascript Library along with Scriptaculous.

Step 1 – Create new RoR Application

First create a new RoR application. Edit the database.yml file as well. If you are new to RoR, then visit Tutorial : Developing your First Ruby on Rails 2 Application

Step 2 – Create a Controller

After creating the new application, we need to create a controller. lets call the controller ajaxfunctions. I hope you guys know how to create a controller.

    ruby script/generate controller ajaxfunctions index

The above code will create a controller called ajaxfunctions which will have a method called index, respectively index.rhtml OR index.html.erb will be created inside the view/ajaxfunctions folder.

Step 3 – Editing the view file

Once you open it, you`ll notice that its empty. This is our template, basic HTML would suffice. So type out an html page here or you can use the one below.





Untitled Document

Great. Now firstly, to implemenet AJAX in RoR , we need to initialize it.

Initializing the Ajax code

You must include the javascript code in your view template file (i.e index.rhtml in our case) for the Ajax functions to be available in that view. The best place for this is in the tag.

You can either use

<%= javascript_include_tag :defaults %>
We`ll be using this. Using this allows for quicker downloads since the script can be cached by the browsers.
This is the output in the HTML page.
```
...





...
```
<%= define_javascript_functions %>
This pastes all of the required Javascript code right into your view which increases your page size by ~20KB.

Different AJAX Helpers used in View Files

RoR creates the AJAX code for you via helper codes. Firstly

Defination:
What is a Helper ?
Helpers (“view helpers”) are modules that provide methods which are automatically usable in your view. They provide shortcuts to commonly used display code and a way for you to keep the programming out of your views. The purpose of a helper is to simplify the view. It’s best if the view file (RHTML/RXML) is short and sweet, so you can see the structure of the output. Nitty-gritty details are best left to helper methods and partials, where they can be parametrized and used repeatedly.

Note : We can call AJAX via 2 methods i.e 1) Using a button and 2) Normal Links. Then we can add the arguments through which we can achieve to have cool visual effects or perform serious AJAX operations.

AJAX Helpers

button_to_function(button_value, *args, ∓block)
Returns a button that‘ll trigger a JavaScript function using the onclick handler. All of these go into the body tag of the view file. You can use the visual_effect function to specify any visual effects

Example :
This will show a button with the value “Greeting”, upon clicking will show a alert box with “Hello World!” inside.
```
<%=button_to_function "Greeting", "alert('Hello world!')" %>
```
This will display a button with value “Fade”, upon clicking will fade in or fade out the element ‘fade_text’ (It can be a div element with id=fade_text).
```
<%=button_to_function "Fade", visual_effect(:toggle_appear, "fade_text", :duration => 0.5)%>
```
link_to_function(name, *args, &block)
Intead of a button, if you want to implement AJAX functionality using a text link. You can use this helper.
Returns a link that will trigger a JavaScript function using the onclick handler and return false after the fact.

Example :
This will show a “Greeting” link, upon clicking will show a alert box with “Hello World!” inside.
```
<%=link_to_function "Greeting", "alert('Hello world!')" %>
```
This will display a “Slide Me” link, upon clicking it will slide in or out the element ‘slide_text’ (It can be a div element with id=slide_text).
```
<%=link_to_function "Slide Me", visual_effect(:toggle_slide, "slide_text", :duration => 0.5)%>
```

Helper for Animation

visual_effect(name, element_id = false, js_options = {})
Returns a JavaScript snippet to be used on the Ajax callbacks for starting visual effects.

Example :
This will show a “Highlight” button, upon clicking will highlight the element which is specified.
```
<%=button_to_function "Highlight", visual_effect(:highlight, "element_id_name",:startcolor => '#ffff99', :endcolor => '#ffffff')%>
```
This will display a “Grow” link, upon clicking it will grow the specified element_id_name
```
<%= link_to_function "Grow", visual_effect(:grow,"element_id_name",:direction => "center",:duration => 1)%>
```

I would really suggest to go through Script.aculo.us WIKI to know more about every effect and their parameters. All of these effects can be used with RoR. For Example I have attached the code for the demo file.

Code for the Demo File

View Demo





AJAX
<%= javascript_include_tag  :defaults %>




<%=button_to_function "Greeting Alert Me", "alert('Hello world!')" %>


Actions with paragraph using buttons
<%=button_to_function "Fade", visual_effect(:toggle_appear, "fade", :duration => 0.5)%>
<%=button_to_function "Slide", visual_effect(:toggle_slide, "fade",:duration => 1)%>
<%=button_to_function "Highlight", visual_effect(:highlight, "fade",:startcolor => '#ffff99', :endcolor => '#ffffff')%>


This is test, This is test

This is testing....

Lorum ipsum blablasadadada


Actions with Green Box using links
<%= link_to_function "Toggle Fade", visual_effect(:toggle_appear, "s1", :duration => 0.5)%> ||
<%= link_to_function "Fade with wobble","new Effect.Fade('s1', { transition: Effect.Transitions.wobble })" %> ||
<%= link_to_function "Grow", visual_effect(:grow,"s1",:direction => "center",:duration => 1)%> ||
<%= link_to_function "Shake", visual_effect(:shake,"s1",:distance => "30",:duration => 1)%> ||
<%= link_to_function "Morph to Red box", visual_effect(:morph,"s1",:style => "{background: '#f00',color: '#fff',width: '200px'}" )%> ||







Drag Action with Blue Box

<%= draggable_element("s2", :revert => true) %>
DRAG ME

Tutorial : Installing Ruby on Rails 2 in Windows Vista/XP
Tutorial : Developing your First Ruby on Rails 2 Application
Tutorial : Basics on Ruby on Rails 2 Model, Controller and Views and Routing
Tutorial : Create a blog using Ruby on Rails 2. (Part 1 – Relationships)
Tutorial : Create a login system in Ruby on Rails

Tutorial : Create a login system in Ruby on Rails

Michael — Thu, 11 Sep 2008 11:10:57 +0000

Hello everyone,
In today’s tutorial I`ll teach you how to create a very basic Login System in Ruby on Rails. Welcome to Tutorial : Create a login system in Ruby on Rails. Before proceeding I would suggest you guys to read Tutorial : Create a blog using Ruby on Rails 2. (Part 1 – Relationships) since we will be using this sytem in our application.

Introduction

We will create a very simple standalone login system first, It will check the database for valid users. Then I`ll let you know how to integrate a similar login system in our blog application. First of course the basics.

We would need to design

Login page
A page which would have to be protected by the login system
Function to Check session, if not valid, then redirect to login page.

Demo of the Login System in RoR : Click Here (user:admin,pass:admin)

Step 1 : Create ‘logintest’ Rails app

Ok, Fire up the command prompt window, Lets create our Rails application called ‘logintest‘.

C:\railsappz>rails logintest -d mysql

After creating the Rails application, you`ll notice a new directory called logintest being created. Navigate inside.

Step 2 : Modify the ‘database.yml’ & Create Tables

Since, our authentication system is going to check the backend for valid users, we need to tell it which database to refer, for the same you need to modify the database.yml file. By now, you must have known this procedure, but for those guys who don`t know how to, here is a lowdown. Navigate to C:\railsappz\login\config, inside it you`ll find database.yml

Open it, then modify the code inside. Please put a valid database name, a valid username and password (mysql). If you want to know how to create databases using phpMyAdmin, read here Tutorial : Using phpMyAdmin to manage mySQL

Secondly, we need to create the ‘User’ Table. This table already has some user information.

CREATE TABLE IF NOT EXISTS `users` (
  `id` int(11) NOT NULL auto_increment,
  `user_name` varchar(255) default NULL,
  `password` varchar(255) default NULL,
  `role` int(11) default NULL,
  `created_at` datetime default NULL,
  `updated_at` datetime default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=3 ;

INSERT INTO `users` (`id`, `user_name`, `password`, `role`, `created_at`, `updated_at`) VALUES
(1, 'admin', 'admin', 0, NULL, NULL),
(2, 'test', 'test', 1, NULL, NULL);

These are the 2 entries we have entered in our User Table.

Username : admin
Password : admin
Username : test
password : test

The following is how MY database.yml looks.

development:
  adapter: mysql
  encoding: utf8
  database: login
  username: root
  password: root
  host: localhost

test:
  adapter: mysql
  encoding: utf8
  database: login
  username: root
  password: root
  host: localhost

production:
  adapter: mysql
  encoding: utf8
  database: login
  username: root
  password: root
  host: localhost

Step 3 : Generate the ‘User’ Model

Creating a model is very important, because for any querying to the database, we need to use a object of this model, similarly to import the form values (login form), we will be using the object of User model.

So we need to tell our app about this mode. Since we are not using database, we`ll skip the database files that normally get created, while creating a model. We`ll use the –skip-migrations option.

C:\railsappz\login>ruby script/generate model user --skip-migrations

Lets move on to creating the User Controller.

Step 4 : Generate the ‘User’ Controller

Now lets create our User Controller. Before creating, Lets do a check on what all we would require, cuz accordingly we have to create our controller.

Login Page
Private Page

So Our controller file will have the login page, private page.

C:\railsappz\login>ruby script/generate controller user login private

      exists  app/controllers/
      exists  app/helpers/
      create  app/views/user
      exists  test/functional/
      create  app/controllers/user_controller.rb
      create  test/functional/user_controller_test.rb
      create  app/helpers/user_helper.rb
      create  app/views/user/login.html.erb
      create  app/views/user/private.html.erb

If you noticed, you`ll see that whatever parameters we specified, view files with the same name are created, i.e login.html.erb, private.html.erb. Basically

Lets decipher the above code,

User – Controller Name
Parameters :

login – Creates a empty function inside user_controller.rb and also creates a view file called login.html.erb which will contain our Login Form.
private – Creates a empty function inside user_controller.rb and also creates a view file called private.html.erb which will contain the content to be protected using our login system.

Step 5 : Edit the Views, viz: login.html.erb, private.html.erb

Navigate to C:\railsappz\login\app\views\user, open up login.html.erb. Time to create our form. We will be using the ruby helpers.

<% if flash[:notice] %>

<%= flash[:notice] %>

<% end %>


<%= form_tag :action=>'authenticate' %>
User name:
<%= text_field("userform", "user_name",:size=>"20" ) %>
Password:
<%= password_field("userform", "password",:size=>"20" )
%>

Save the file, now open up private.html.erb. This will be our protected page. If someone tries to view this page directly he should be redirected to the login page. Only valid users should be able to see this page.


hello <%=session[:user_id]%>.


<%= link_to "logout",:controller => "user", :action => "logout" %>

Ok, Now we have defined our view files and used some methods inside them, now its time to define these methods. All methods go inside the controller.

Step 6 : Edit the user_controller.rb

Navigate C:\railsappz\login\app\controllers and open user_controller.rb. You will notice 2 empty methods viz login, private. Let them be the way they are for now, We will be creating 2 methods, first lets create a method to handle our authentication viz authenticate.

def authenticate
		#User.new(params[:userform]) will create a new object of User, retrieve values from the form and store it variable @user.
		@user = User.new(params[:userform])
        #find records with username,password
		valid_user = User.find(:first,:conditions => ["user_name = ? and password = ?",@user.user_name, @user.password])

        #if statement checks whether valid_user exists or not
		if valid_user
        #creates a session with username
			session[:user_id]=valid_user.user_name
        #redirects the user to our private page.
			redirect_to :action => 'private'
		else
			flash[:notice] = "Invalid User/Password"
			redirect_to :action=> 'login'
		end
end

Second method is for to handle the logout. When the logout link will be clicked, this method will be called. As you can see, we will reset the session created during authenticate method and redirect the user to the login page again.

  def logout
	  if session[:user_id]
		  reset_session
		  redirect_to :action=> 'login'
	  end
  end

Now to test the server. Run ruby script/server. You will see the usual Riding on Rails Page.
Point your browser to http://myserver.dev:3000/user/login to see the login page.

If you have followed all the steps properly, you`ll see that the login system is working fine, except for a lil important modifications.

First logout, then Try pointing your browser to http://myserver.dev:3000/user/private, you`ll notice that you are able to view the private page !!!
Lets rectify this problem

Step 7 : Modify the private method in user_controller.rb

Since we just have to protect one page, we can simply use an if statement to check the session and respectively allow or disallow them to view the private page. Remember we had created a private method in user_controller.rb (Our User Controller). So your new private method will look like the following

  def private
 	 if !session[:user_id]
    	redirect_to :action=> 'login'
	end
  end

Voila ! We have secured our private page. Finally

This is how your final User_controller.rb should look

class UserController < ApplicationController
def authenticate
		#User.new(params[:userform]) will create a new object of User, retrieve values from the form and store it variable @user.
		@user = User.new(params[:userform])
        #find records with username,password
		valid_user = User.find(:first,:conditions => ["user_name = ? and password = ?",@user.user_name, @user.password])

        #if statement checks whether valid_user exists or not
		if valid_user
        #creates a session with username
			session[:user_id]=valid_user.user_name
        #redirects the user to our private page.
			redirect_to :action => 'private'
		else
			flash[:notice] = "Invalid User/Password"
			redirect_to :action=> 'login'
		end
end

  def login
  end

  def private
  if !session[:user_id]
	redirect_to :action=> 'login'
	end
  end

  def logout
	  if session[:user_id]
		  reset_session
		  redirect_to :action=> 'login'
	  end
  end

end

Now to test the server again, Re-Run ruby script/server.
Try pointing your browser to http://myserver.dev:3000/user/private, you will see that you will be redirected to the login page (if you previously logged out, else if the session is still valid, you`ll see the private page).

Phew… Well thats about how to design the Login System in Ruby on Rails. If you guys have any problems, as usual you can always post a comment here. I`ll be posting another post on how to integrate this login system in our blog application.

Demo of the Login System in RoR : Click Here (user:admin,pass:admin)

Tutorial : Create a blog using Ruby on Rails 2. (Part 1 – Relationships)

Michael — Sun, 24 Aug 2008 09:06:16 +0000

Hello !
Its been a long time since my last post. I have been hell busy this week, barely had time to update. This is the revised version.

This tutorial will form the base for the upcoming series of tutorials on how to create a simple blog application in Ruby on Rails(RoR).
Part 1 will discuss about how relationships are defined in RoR and the basics as usual

Index

Page 1 : Introduction
Page 2 : Create Scaffolds application
Page 3 : Modifying the Model,Controller and View

Introduction

Let me explain what we are trying to create. We will be creating our own very simple blog application using Ruby on Rails. The blog will have

A Simple Login System
A Simple Administrative Interface to manage posts,categories and comments
Display comments for every post
Ajax Implementation

What all you`ll learn :

To create and work with scaffolds
Relationships in Rails
Migrations
How Models, Controllers and Views work
A simple login system
Ajax Implementation in this blog

A lot more as we go on …

Some Conventions in Rails

The name of the table must be in its plural form: By default everytime we create a scaffold, the table created will be of its pluralized form. Rails will derive the singular name for the corresponding class automatically.
For Example. If we create a scaffold called category, Rails will automatically derive its plural form i.e categories.
By default primary key called id will be created for every scaffold even if not specified. The Data type of the Primary key should be Integer.
The Foreign keys should be named ‘table name of the referenced table + _id’
For Example : if we want to use Table-Category’s Primary key ‘id’, we`ll create a attribute called category_id in our ‘posts’ table.

What are we doing in Part 1 ?

In this tutorial (Part 1 of the Series) we`ll learn how to create different categories and assign our posts to these categories. Every post will show which category it belongs to.

So to achieve this, we need 2 tables. The database schema for the same will be something like

category(id,category_name)
post(id,post_title,post_text,date_of_creation,category_id)

The schema is pretty self explainatory. category_id of ‘post’ is the attribute which will contain the id of ‘category’. The simplest way to put this is, every record inside the post table will contain category_id which will help us retrieve the category_name by referring to the other table i.e category.

Pre-requistes :

I would really suggest you people to read the following tutorials, to understand the basic of RoR.

Please have a developer environment set up. For more information on how to set it up, read
Tutorial : Installing Ruby on Rails 2 in Windows Vista/XP
Tutorial : Developing your First Ruby on Rails 2 Application
Tutorial : Basics on Ruby on Rails 2 Model, Controller and Views and Routing

Tutorial : Basics on Ruby on Rails 2 Model, Controller and Views and Routing

Michael — Thu, 14 Aug 2008 05:24:28 +0000

Hey Guys,

Finally I got 2 days off from my college *yay*. Now there will be lots of updates. Anyways, You must have noticed the new “Featured Flash Widget” and some small changes here and there, the site is being updated constantly with a lil tweaks here and there, so please bear with it. Today I`ll show you how to create a simple “Hello World” application in RoR2. When I was trying to learn RoR2, there were no articles on how to create a simple “Hello World” application. So I thought I`ll take this time to introduce all the newbies to Ruby on Rails 2 on how to create a simple Hello World App.

If you don`t know how to install RoR2 in your system and want more information about Ruby on Rails 2, do read this tutorial
Tutorial : Installing Ruby on Rails 2 in Windows Vista/XP (4.75 out of 5)

Index

Tutorial : Developing your First Ruby on Rails 2 Application

Michael — Wed, 09 Jul 2008 19:30:44 +0000

So, you want to make an application using Ruby on Rails (RoR) huh ! Well, Lets try to make a simple “Article System”. Ruby on Rails is very easy at the same time a lil complicated. If you want to know more theory about Ruby on Rails, you can visit its official homepage http://www.rubyonrails.org. If you want a small summary of what it is, you can read my previous post Tutorial : Installing Ruby on Rails in Windows Vista/XP.

Like I said in my previous post, RoR uses the MVC Architecture. (M-Model, V-Views, C-Controller)

The below diagram must be self-explainatory, but if it is not, then
Models – Models communicate with the database, to retrieve the data and keep.
Controller – Any requests made by the browser are forwarded to the Controller by the View, which refers the Models and modifies it in different ways (methods written in the Controller) and returns the results to View.
View – This communicates with the browser, takes the inputs and forwards it to the Controller for the respective action, and the returned result from the Controller is forwarded by the view back to the browser.

Anyways, that was about MVC. So in RoR we always have to create these files for different functions.
For our Article System, our objective is to create a system in RoR

Create Database ‘articlesystem_development’
Take Article input from User
Display All the Article
Edit Article
Delete Article

If we were to use PHP, this system would take not less than 50 Lines of Code, but in RoR …. you`ll soon find out;)

Firstly open up Command Prompt (Start->Run) type cmd and click OK, then lets navigate to our ruby folder and create our application.
The Syntax to create a new application is
```
rails -d mysql appname
```
So type
```
C:\ruby\bin\>rails -d mysql articlesystem
```
A long list of files & directories are created.
Before editing, Create a database articlesystem_development through phpmyAdmin. If you don`t know how to create a database then refer to Tutorial : Creating a Content Management System using PHP/MySQL else you can use the mysql command to create the database.
1. Goto Start->Run. Type cmd and hit Enter. You will be prompted with the command prompt.
2. type mysql -u username -p, hit enter
3. It`ll prompt you for your password. Enter the password.
4. Once your inside the console type CREATE DATABASE databasename \g i.e mysql>CREATE DATABASE databasename \g
5. If you see the following then you have successfully created a database.
```
mysql> create database boo \g
Query OK, 1 row affected (0.00 sec)
```
Good ! Now navigate to F:\server\ruby\bin\articlesystem\config and open the file ‘database.yml’ in wordpad.
```
development:
adapter: mysql
encoding: utf8
database: databasename
username: username
password: password
host: localhost

test:
adapter: mysql
encoding: utf8
database: databasename
username: username
password: password
host: localhost

production:
adapter: mysql
encoding: utf8
database: databasename
username: username
password: password
host: localhost
```
You will see the following,except the password area has not been edited yet so type in your mysql user password. (If you have followed the previous tutorial, then password is root), and please enter the same database name in all development,test and production.
Save the file.
Now comes the fun part. Open up Command Prompt. Now we need to create the tables for our database.
Our database schema is

id(int) title(string) article(text)
1 test article bla bla bla.. lot of content

The above post was just an example, so basically we have 3 attributes i.e id, title and article.
We will be using rails “Scaffolding” feature to create these tables and link it with our system. Scaffolding as the name says, to clean the windows of a high rise building, scaffolding is used as support temporarily, similarly here we are going to use ‘scaffold’ to generate links & code.

Now type in

c:\ruby\bin\articlesystem>ruby script/generate scaffold article title:string article:text

You`ll see notice that rails creates another bunch of files

C:\ruby\bin\articlesystem>ruby script/generate scaffold article title:string article:text
exists  app/models/
exists  app/controllers/
exists  app/helpers/
create  app/views/articles
exists  app/views/layouts/
exists  test/functional/
exists  test/unit/
exists  public/stylesheets/
create  app/views/articles/index.html.erb
create  app/views/articles/show.html.erb
create  app/views/articles/new.html.erb
create  app/views/articles/edit.html.erb
create  app/views/layouts/articles.html.erb
create  public/stylesheets/scaffold.css
create  app/controllers/articles_controller.rb
create  test/functional/articles_controller_test.rb
create  app/helpers/articles_helper.rb
route  map.resources :articles
dependency  model
exists    app/models/
exists    test/unit/
exists    test/fixtures/
create    app/models/article.rb
create    test/unit/article_test.rb
create    test/fixtures/articles.yml
create    db/migrate
create    db/migrate/20080709183936_create_articles.rb
C:\ruby\bin\articlesystem>

I know, there are hell lot of files being created !! Anyways, I`ll just tell you what RoR has generated, it has managed to create
- article.rb -> Model inside c:\ruby\bin\articlesystem\app\models\,
- articles_controller.rb -> Controller (Which has methods of all the functions i.e Create,delete,showall,edit) inside c:\ruby\bin\articlesystem\app\controllers
- index.html.erb, edit.html.erb, new.html.erb, show.html.erb -> View Files (More like templates which determine the looks of the site) inside C:\ruby\bin\articlesystem\app\views\articles
Remember MVC … you can check the code out. But don`t modify any right now.
Now all you have to do is create the tables of the database. Hold on your horses, no need of logging in to mysql to create your tables. Just type this code
```
C:\ruby\bin\articlesystem>rake db:migrate
```

rake db:migrate -> executes the database schema RoR had generated automatically,
Not only did RoR generate so many files, It also generated the table schema for articles.

# This file is auto-generated from the current state of the database. Instead of editing this file,
# please use the migrations feature of Active Record to incrementally modify your database, and
# then regenerate this schema definition.
#
# Note that this schema.rb definition is the authoritative source for your database schema. If you need
# to create the application database on another system, you should be using db:schema:load, not running
# all the migrations from scratch. The latter is a flawed and unsustainable approach (the more migrations
# you'll amass, the slower it'll run and the greater likelihood for issues).
#
# It's strongly recommended to check this file into your version control system.

ActiveRecord::Schema.define(:version => 20080709183936) do

create_table "articles", :force => true do |t|
t.string   "title"
t.text     "article"
t.datetime "created_at"
t.datetime "updated_at"
end

end

Voila !!! RoR has just created all the necessary tables for you in mysql. Don`t believe me ? go check your database. Don`t be amazed, thats nothing, now time to test our code, invoke the ruby web server
```
C:\ruby\bin\articlesystem>ruby script/server
```
Point your web browser to http://localhost:3000/articles
Congratulations !!! you have developed your first application in Ruby on Rails 2. Play around with the application, see what all you can do. RoR by default creates the delete,edit,create,show functions for your application when using “scaffold”. You can add articles, delete em, edit em or view all of em, from just 3 lines of code

This is the power of RoR !! Although I wrote a very basic tutorial (since I had less time), this tutorial covers a little theory of RoR’s architecture, how to create an application using rails in development mode, how to create a scaffold and finally to rebuild the database using rake db:migrate.

So I hope you had fun, you can modify the view files in C:\ruby\bin\articlesystem\app\views\articles if you want to change the look of it.

You can make the application start directly from http://localhost:3000/ I`ll be showing that, in my next tutorial for RoR which includes basic link routing, some more extra features to our article system. In the next tutorial I`ll also discuss about the singular & plural concepts in RoR which are very important. Till then Chow !

Found this tutorial really useful, you can click here to donate.

Tutorial : Installing Ruby on Rails 2 in Windows Vista/XP

Michael — Wed, 09 Jul 2008 12:09:19 +0000

Greetings,

Most of you must have heard of “Ruby on Rails (RoR)”. It being touted as the next best thing (apart from php ). Well lemme give you a lowdown of what Ruby on Rails is…

I`ll try to explain the power of RoR in the simplest of words,

If PHP can do something after typing 75 lines of code, RoR can do the same thing in typing mearly 3 lines of code !!!!
Thats as simple is it gets ! But then again, there is a catch to it, RoR is equally complex. So Today, I`ll just give you the basic idea of what Ruby on Rails is, and how to set up a developer environment for RoR, So next time we can directly start creating applications. woohoo !

But Firstly the basics.
If you are aware of the basics then Click Here to jump below, else read on.

“Ruby is a dynamic, reflective, general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. Ruby was initially developed and designed by Yukihiro “Matz” Matsumoto.”

Ruby is very similar to our native object-oriented programming languages (eg: C++,Java).
You can define variables using ‘@’ symbol.
You can define functions, more commonly known as methods using
```
def method_name
....
end
```

“Ruby on Rails is framework developed particularly for web applications. The framework is coded using Ruby. It basically makes our lives easier by generating code automatically on execution of a single piece of code.

It uses the MVC Architecture. (Model-View-Controller, I`ll be explainin this in the next tutorial, which will be ‘Creating Your First RoR Application’)

I like to tell you that, its not easy deploying a RoR application (Thats right, its an application, not a script or a piece of code, but a combination of lots of directories & files).
Its not anything like the php scripts we upload to the server and run the script by pointing to the right address, there are various modes on how a RoR application is executed (Eg. developer, test, production).

Enough of the technical mumbo-jumbo, lets get down business.

Pre-Requisites :

Webserver + MySQL installed
Ruby (1.8.6) : We need to install the basic ruby binaries and extensions to execute RoR applications.
Download ruby186-26.exe

Basically you must have a normal php/mysql developer environment already installed, if not, you can refer to my earlier tutorial i.e
Tutorial : Installing Apache, PHP5, MySQL5, PhpMyAdmin 2.11 in Windows Vista/XP

Vision Master Designs » Ruby on Rails

Tutorial : Introduction to AJAX in Ruby on Rails with Prototype, Script.aculo.us

Introduction

Step 1 – Create new RoR Application

Step 2 – Create a Controller

Step 3 – Editing the view file

Initializing the Ajax code

Different AJAX Helpers used in View Files

Helper for Animation

Code for the Demo File

Actions with paragraph using buttons

Actions with Green Box using links

Drag Action with Blue Box

Related Articles

Tutorial : Create a login system in Ruby on Rails

Introduction

Step 1 : Create ‘logintest’ Rails app

Step 2 : Modify the ‘database.yml’ & Create Tables

Step 3 : Generate the ‘User’ Model

Step 4 : Generate the ‘User’ Controller

Step 5 : Edit the Views, viz: login.html.erb, private.html.erb

Step 6 : Edit the user_controller.rb

Step 7 : Modify the private method in user_controller.rb

Related Links

Tutorial : Create a blog using Ruby on Rails 2. (Part 1 – Relationships)

Index

Introduction

Some Conventions in Rails

What are we doing in Part 1 ?

Tutorial : Basics on Ruby on Rails 2 Model, Controller and Views and Routing

Index

Tutorial : Developing your First Ruby on Rails 2 Application

Tutorial : Installing Ruby on Rails 2 in Windows Vista/XP