In our previous set of Videos, we have covered basics of a Web Application, MVC architecture and also basic introduction to Ruby and Rails.

In this post, we have videos which explain certain tools which can be used to speed up our development process. They are:

1. Command Line
2. Text Editor
3. Rails & Ruby Overview

---

Command Line

Summary:

We use Terminal in Mac, Command prompt in Windows and X-terminal in Unix/Linux. In windows, we can access this by going to ‘Start’ button, then ‘Run’ and then type ‘cmd’. The author explains how to use Command Line to navigate between files and Rails files in particular and also to check the version of Rails installed and some commands to operate Rails from command line. It would be dealt with detail in the coming videos.

---

Text Editor

Summary:

The author explains the working of Text-Mate, a text editor used extensively by Programmers on Mac OS. Since I don’t use Text-Mate, I have no summary to offer 🙂 . Windows text-editors are explained in Installation of Rails on Windows videos.

---

Overview of Ruby and Rails

Summary:

For development on Ruby on Rails, we need Ruby Language and Rails Framework.

Ruby language is a scripting language developed by a Japanese in 1990’s. Installation of Ruby on Windows is a simple Double-click which will be dealt in detail in coming videos.

Rails framework installation is also discussed in coming videos. After its installation, Rails framework is saved in a particular file format which will also be discussed later.

---

Disclaimer: The Screencasts are not recorded by me. I have just embedded them from Youtube. The original Videos area a part of Virtual Training Company, who give Online Training and the author for Ruby on Rails Series is Mr. Al Anderson. If you are benefited from these, you may register there by paying certain amount or order a CD from them.

In this post, the following Concepts are explained

1. Web Applications and Rails
2. What Rails can Do
3. Where Rails Came From
4. Rails Philosophies
5. More Rails Philosophies
6. MVC
7. Model
8. View Part 1
9. View Part 2
10. Controller

Web Applications and Rails

Summary:

Basic introduction to Web applications in general. The architecture of Web browser(Cleint) and Server(which also includes a Database) is explained. Model-View-Controller architecture of Rails is also explained very well. A must see for newbies.

---

What Rails can Do

Summary:

Examples of usages of Ruby on Rails in some of the Deployed and running web applications. The author also explains a web app he had developed with Rails (Please dont be upset with the layout of this app, the functionality matters ). The app developed by him shows the power of Rails prototyping at a much faster rate compared to other frameworks. He also goes on to explain different Rails website showcased on Rubyonrails official website.

---

Where Rails Came From

Summary:

This explains the background for the development for Ruby on Rails. A company based out of Chicago by name 37Signals hired a smart developer from Denmark by name David Heinemeier Hansson to work on a Collaborating Web-app Basecamp . Because of the Geographical distance between them, an interesting Design pattern and philosophy was developed which has crept its way into Ruby on Rails. Rails has been extracted into a framework from a product (BaseCamp), which is not quite the usual case. The author also recommends to watch the Video presentation by David on Rails and its background.

---

Rails Philosophies

Summary:

This covers the Philosophies behind Rails

DRY (Dont Repeat Yourselves)

One piece of information should be present only at a single place. Most of the code should be placed only once in specific places based on MVC paradigm. This makes the code highly efficient and easy to maintain.

Convention over Configuration

Rails follows certain Conventions, that is it has defaults for most aspects of putting together a web application. If you follow these conventions, you can develop Web apps rapidly not bothering about a lot of Configurations which you would otherwise do in Java or normal PHP. This also makes your code base very minimal

---

More Rails Philosophies

Summary:

Another philosophy behind Rails is Agile Development. It emphasizes more on important things rather than conventional standards. In the following list, the items in bold text have emphasis over the normal text.

• Individuals and interactions over processes and tools
• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan

---

MVC

Summary:

A brief history and introduction to MVC architecture. The pattern was first described in 1979 by Trygve Reenskaug, then working on Smalltalk at Xerox PARC

The components of MVC are Model-View and Controller.

1. Model maintains the state of your application.
2. View is responsible for generating User Interface through which a website user interacts with it
3. Controller can be perceived as the part which controls and co-ordinates the View and Model.

In Rails, M-V-C files are under separate folders and Model and Controller files have .rb extension whereas View files have a .rhtml(html with Ruby Code embedded) or .rjs (JavaScript embedded with Ruby Code).In Rails, the MVC works as follows.

A URL from Web-browser interacts with a Controller (not a View directly). Controller then interacts with Model which makes queries into the Database. The Database replies with the output to Model which will return to Controller in the form of Object Oriented array, which can be manipulated and then sent to the View which renders the html and Javascript on the Web-browser.

---

Model

Summary:

Model interacts with database and maintains state of the database in a Rails Application. In Rails, we extensively use Active Record which is a ORM (Object-Relational Mapping ) mechanism. Every model-class in Rails app corresponds to a Table in our Database. Every attribute in a model-class is mapped to a column in the corresponding database table. All these are done automatically once you instantiate a Model (Thanks to Rails, which takes care of this headache ). Author also shows and explains some Code of a model class. The ActiveRecord is intelligent enough to update itself with any Database changes you make. So it truly uses DRY i.e you dont have to make any changes in the Model file after you make changes in the Database. He also explains the syntax of a Model file(tech.rb), which is

[sourcecode language=’ruby’]
class Tech < ActiveRecord::Base #Tech as a subclass of ActiveRecord Class has_many: work_requests # one to many mapping, work_requests is another model-class has_many: assigned_teches has_many: work_requests_notes def self.login(name,password) find(:first, :condtions => [“name = ? and password = ?”, name, password])
end

def try_to_login
Tech.login(self.name, self.password)
end
end
[/sourcecode]

---

View Part 1

Summary:

View is the Part of the MVC architecture which renders or parses the generated html and javascript code to the Browser. Compared to Model and Controller files(.rb) which are Classes and have only Ruby code in them, View files(.rhtml or .rjs) have html and/or javascript code and have Ruby code embedded in them between <% …some ruby code…%>

The author shows and explains a simple Recipe list which has Recipes with add/edit/delete and search functionalities. He goes through the Controller code which will in-turn parse to View to render html to browser. Name of the Controller file and Controller class are related and is generated by Rails. In this example, the controller’s class name is RecipeController and the controller file name is recipe_controller.rb , which is as follows

[sourcecode language=’ruby’]
class RecipeController < ApplicationController # Subclass of ApplicationController def list #function or method. An important convention is that it parses a view file by the same name. i.e list.rhtml and is not explicitly mentioned @all_recipes = Recipe.find(:all) #It finds all the recipes and stores in instance variable 'all_recipes' end def view @a_recipe = Recipe.find(params[:id]) #it finds a recipe with a given id @all_recipes = Recipe.find(:all) #It finds all the recipes end def show_add_recipe end def search title = "%" + @params[:title] + "%" @all_recipes = Recipe.find(:all, :condtions=>[“title like ?”, title])
end

def add_recipe
@a_recipe = Recipe.new(params[:new_recipe])
@a_recipe.save
redirect_to :action => ‘list’
end

def delete_the_recipe
Recipe.find(params[:id]).destroy
redirect_to :action => ‘list’
end

def edit_recipe
@recipe_to_edit = Recipe.find(params[:id])
end

def save_recipe
@recipe_to_update = Recipe.find(@params[:a_recipe_id])
@recipe_to_update.update_attributes(@params[:recipe_to_edit])
redirect_to :action => ‘list’
end

end
[/sourcecode]

---

View Part 2

Summary:

From the previous Video, we look at list.rhtml. It is called by ‘list’ method/function in RecipeController class. The beauty of Rails is that you dont have to specify the name of the View file, its convention is to have the Controller class name itself. In this case it is list.rhtml whose content is as follows

[sourcecode language=’html’]

<%= flash[:notice] %>

<%= render(:partial => ‘the_list”)%>

[/sourcecode]

In the above snippet of code, the major part is normal html. The Ruby code is put between <% …some code … %> if its not printing anything on the browser . If you are outputting or printing something, we use <%= ..some code.. %>.

The line <%= render(:partial => “the_list”) %> renders another view, in this case its a partial view. The partial views can only be called from main views and hence can be used repeatedly at many places. The partial view file is named _the_list.rhtml . There is an underscore before the file name to distinguish it as a partial view. The contents of ‘_the_list.rhtml’ file is as follows

[sourcecode language=’html’]

<% for a_recipe in @all_recipes%>

<% end%>

<%=link_to "View Recipe", :action=> ‘view’, :id=> a_recipe %>

<%=a_recipe.title %>

<%=a_recipe.description %>

<%=link_to "Edit", :action=> ‘edit_recipe’, :id=> a_recipe %>

<%=link_to "Delete", :action=> ‘delete_the_recipe’, :id=> a_recipe %>

---

<%= render(:partial => “search_form”)%>
<%= link_to "Add New Recipe", :action => ‘show_add_recipe’ %>
[/sourcecode]

In the above snippet of code,

• @all_recipes which is parsed from RecipeController is taken on a Loop.
• On every iteration, variable ‘a_recipe’ is rendered in a new table-row.
• To print the title of a recipe, we use a_recipe.title and similarly for description, we use a_recipe.description.
• In <%= link_to ‘View Recipe”, action=> ‘view’, :id=> a_recipe %> , link_to is a Ruby function which builds an anchor or link with text “View Recipe” and clicking on it will trigger ‘view’ function in RecipeController and parses ‘id’ as an argument.
• <%= render(:partial => “search_form”) %> will render “_the_search_form.rhtml” file

---

Controller

Summary:

Controller can be thought of a co-ordinator between a model and a view. A controller is usually called by a URL from the web-browser. Say there is a URL request of http://0.0.0.0:3000/recipe/list , it directly goes to controller recipe, whose filename is recipe_controller.rb and whose class name is RecipeController. All these would seem a bit confusing at first, but once you are familiar with the conventions, it would be a cake walk in future. The next part of the url after the controller name is ‘list’, which is the function name inside ‘recipe’ controller.

Lets explore ‘recipe_controller.rb’ file

[sourcecode language=’ruby’]
class RecipeController < ApplicationController # Subclass of ApplicationController, Class is i def list #function or method. An important convention is that it parses a view file by the same name. i.e list.rhtml and is not explicitly mentioned @all_recipes = Recipe.find(:all) #It finds all the recipes and stores in instance variable 'all_recipes' end def view @a_recipe = Recipe.find(params[:id]) #it finds a recipe with a given id @all_recipes = Recipe.find(:all) #It finds all the recipes end def show_add_recipe end def search title = "%" + @params[:title] + "%" @all_recipes = Recipe.find(:all, :condtions=>[“title like ?”, title])
end

def add_recipe
@a_recipe = Recipe.new(params[:new_recipe])
@a_recipe.save
redirect_to :action => ‘list’
end

def delete_the_recipe
Recipe.find(params[:id]).destroy
redirect_to :action => ‘list’
end

def edit_recipe
@recipe_to_edit = Recipe.find(params[:id])
end

def save_recipe
@recipe_to_update = Recipe.find(@params[:a_recipe_id])
@recipe_to_update.update_attributes(@params[:recipe_to_edit])
redirect_to :action => ‘list’
end

end
[/sourcecode]

In the following snippet of code, RecipeController class is made a sub-class of ApplicationController, meaning it derives all the properties of ApplicationController (Inheritance property of OOP). The class should always be terminated by ‘end’
[sourcecode language=’ruby’]
class RecipeController < ApplicationController ..... ..... end [/sourcecode] In the following snippet of code, 'list' is a function/method. It is defined by keyword 'def' followed by its name. It is terminated by 'end'. Whatever is in between them is executed upon calling the function. In this case, there is a ActiveRecord Model named 'Recipe'. Recipe.find(:all) will interact with recipe corresponding table in database and get all the rows. The relational data from database is converted into Object by ActiveRecord and it is assigned to instance variable @all_recipes in the form of an array. Once this is done, the function will then call the view file with the same name as its, and parse the instance variables. In this case, it would be 'list.rhtml' as we had covered in the previous video summary. [sourcecode language='ruby'] def list @all_recipes = Recipe.find(:all) end [/sourcecode] Since a Controller is the co-ordinator for Views and Models, if we have less code in View and more in Controller, it would become easy to maintain and update the code.

---

Disclaimer: The Screencasts are not recorded by me. I have just embedded them from Youtube. The original Videos area a part of Virtual Training Company, who give Online Training and the author for Ruby on Rails Series is Mr. Al Anderson. If you are benefited from these, you may register there by paying certain amount or order a CD from them.

Welcome to Ruby on Rails

Summary :

It is intended for completely novice beginners. There is a brief introduction given to

1. Web Applications: How exactly any Web Application deployed on a server would function ?
2. Ruby Language: “Ruby is a dynamic, reflective, general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. Ruby originated in Japan during the mid-1990s and was initially developed and designed by Yukihiro “Matz” Matsumoto“
3. Rails Framework: Rails framework is a series of Ruby Code written to develop a Web application, making Rapid Web application development very straight forward. “Ruby on Rails was extracted by David Heinemeier Hansson from his work on Basecamp, a project management tool by the web design (now web application) company 37signals“

---

What this Tutorial will Cover ?

Summary:

This is again intended for Novice learners. In this video, a outline or the Things to be covered in Tutorial Set has been given, which is as follows.

1. What is Ruby on Rails? – A brief intro
2. Where did it come from ? – A brief history
3. How and what it does ?
4. How to install Rails on Windows/ Mac ?
5. What are different tools used for Development and Deployment ?
6. What are the programming constructs ?
7. How to build Database backed Applications ? – Usage of CRUD
8. What are the resources available ?

---

Disclaimer: The Screencasts are not recorded by me. I have just embedded them from Youtube. The original Videos area a part of Virtual Training Company, who give Online Training and the author for Ruby on Rails Series is Mr. Al Anderson.  If you are benefited from these, you may register there by paying certain amount or order a CD from them.