How to Check If Someone is Invisible, Offline Or Blocked You On GTalk

GTalk is one of the most used messaging services on internet.

Initially Gtalk was not having any invisible option in it. Which means you will get noticed by all your friends once you log in. But later, after a lots of requests from it’s users, GTalk decided to start this invisible feature. But, they started this invisible feature for those who uses GTalk from GMail or Orkut. If you are using GTalk from your desktop, you may not get this facility.

In this post I will guide you with three things that you might find interesting. You can consider these as GTalk tricks. And the three things are:

1. How to know if someone is invisible on GTalk.
2. How to know if someone is offline or not.
3. How to know if someone has blocked you on Gtalk or not.

Lets get started step by step. I am sure, you will have fun reading these Gtalk tricks.

How To Know if Someone is Invisible or Offline on GTalk :

People activate this invisible feature for many reasons. They might be busy or do not want anyone to disturb them. They want to chat with few people they want or they want to stay hidden and contact the persons they wish. I always stay invisible on Gtalk, so that I can talk with the persons I want

Now if you want to fool the people and know about their online status even when they have logged in with invisible feature activated, then this is possible. Poor Gtalk! There are two ways to do this.

• After  the Gtalk  installation, log on to your GTalk account with your login details.
• Now, this will show you the entire online friends list. It does not matter if they are online or invisible.
• In this way you can catch your offline friends as well. The persons who are being shown as offline, are not present on GTalk.
• And you are done above. You will notice those online (visible + invisible) as well as the offline friends.

And the second method  is :

• Set the chat as off the record with target user. This can be done only when the other user is online.
  
• Now try sending chat to that user when he is invisible or offline.
• If he is invisible, then he will receive chat.
• But if he Is offline, then you will receive error “<username> did not receive your chat”.

How to Know if Someone Has Blocked You on Gtalk :

Now this is worth exciting. Few times we notice friends not contacting us for a long time. Even though we send them messages, they never reply us back. It can happen because of three reasons.

He/She is avoiding  or offline blocked you on Gtalk.

Whatever the reson may be, it’s nice to find the reason yourself. Let’s find out the exact reason of not getting a reply back. But for this you need to have PIDGIN and configure it properly. Pidgin is a third party tool, available for free. You can use all your messenger accounts at once using this software. You can talk to your friends using AIM, ICQ, Jabber/XMPP, MSN Messenger, Yahoo!, Google Talk, Bonjour, Gadu-Gadu, IRC, Novell GroupWise Messenger, QQ, Lotus Sametime, SILC, SIMPLE, MySpaceIM, Zephyr etc. Read the below steps properly.

How to configure PIDGIN for GTalk :

• Download Pidgin.
• Go To Accounts –> Manage –> Add.
• It will open a new window Add Accounts.
• From the drop down box choose XMPP as the Protocol.
• In case of Screen name enter your Gmail Id (e.g. – solid.blogger).
• Type gmail.com as the Domain/Server.
• In Resource Field enter Home.
• Type your Gmail Password in the Password Field.
• Choose any Nickname (e.g. – Bapun) as Local alias.

And you are done with Pidgin settings. Now lets play with Pidgin to find those GTalk contacts who has blocked you. For this follow the below mentioned steps.

1. sign in to GTalk on PIDGIN with your details

2. Go to Buddies –> Show Offline Buddies (The person who has blocked you is being shown as offline to you. So, in this way you can catch him.)

3. Now all available contacts will be visible to you. Select any one contact from that list.

4. Right click on that selected contact, and click on Get Info.

5. Now here is the twist. Clicking on Get Info will show the brief profile of the person. But now if the person has blocked you on Google Talk, you won’t be able to see his/her full profile. You can’t even see his/her profile name.

This is the best way to know if someone has blocked you on google talk or not. If he has blocked you, then he will appear to you forever.

Silverlight with Ruby on Rails

Using Silverlight with Ruby on Rails

In this post I will be showing a really simple example of creating a Silverlight frontend for a Rails backend. This is what I think will be a three part series comparing Silverlight with Flex.

The steps will be:

1. Creating a Rails application.
2. Creating a frontend for it in silverlight.
3. Creating a frontend for it in Flex.
4. Comparing the approaches taken in both the frontends.

I will try to keep changes in the backend Rails application to a minimum.

Creating a Rails Application

F:\>rails test
F:\>cd test
F:\test>ruby script\generate scaffold user name:string address:text
F:\test>rake db:create
F:\test>rake db:migrate
F:\test>ruby script\server

Before running the migrations add the following code in the first migration file (./db/migrate/001_create_users.rb) to create some initial data. So it should look like:

class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.text :address
t.timestamps
end

User.create(:name=> “Gaurav”, :address=> “Gaurav’s address”)
User.create(:name=> “Rishav”, :address=> “Rishav’s address”)
User.create(:name=> “Bhavesh”, :address=> “Bhavesh’s address”)
end

def self.down
drop_table :users
end
end

Creating a new C# based Silverlight project

Open up Visual Studio 2008 (with Silverlight tools installed. You can also download a trial version of Visual Studio 2008 from here). And create a new project:

Open the page.xaml file and add a ListBox to it. It should look like:

<UserControl x:Class=”TestFrontEnd.Page”
xmlns=”http://schemas.microsoft.com/client/2007″
xmlns  =”http://schemas.microsoft.com/winfx/2006/xaml”
Width=”400″ Height=”300″>
<Grid x:Name=”LayoutRoot” Background=”White”>
<ListBox x:Name=”userList” Height=”200″/>
</Grid>
</UserControl>

Now when the server responds with xml, we will parse that using Linq. For that we need a User class that is like the user model on the Rails side. So it should have 3 fields:

1. id
2. name
3. address

It should look like:

namespace TestFrontEnd {
public class User {
public int id { get; set; }
public string name { get; set; }
public string address { get; set; }
}
}

To make things simpler I have created a HTTPService class that behaves something like the Flex based HTTPService class. Here is the source (too big to paste inline). Add it to your project. You will need to include System.Net assembly your project to to make it work. Its usage is quite simple.

HTTPService userIndexService = new HTTPService();
userIndexService.Url = “http://localhost:3000/users.xml”;
userIndexService.ServiceComplete += new HttpServiceCompleteEventHandler(userIndexService_ServiceComplete);
userIndexService.send();

You can also give the request method like:

userIndexService.Method = “POST”;

Now add an ObservableCollection to the Page class:

private ObservableCollection<User> userListItems = new ObservableCollection<User>();

We will be using this for databinding with the ListBox to display all the users.

Add the System.Xml.Linq to your project. In the userIndexService_ServiceComplete event handler write:

void userIndexService_ServiceComplete(HttpServiceCompleteEventArgs e) {
XDocument users = XDocument.Parse(e.Response);
User[] usersList = (from x in users.Descendants(“user”)
select new User
{
id = int.Parse(x.Descendants(“id”).First().Value),
name = x.Descendants(“name”).First().Value,
address = x.Descendants(“address”).First().Value,
}).ToArray();
foreach (User user in usersList)
userListItems.Add(user);
}

So when the service completes all the users will be filled in the ObserveableCollection. Now to bind it to the userList ListBox. In the constructor of the Page class write:

userList.DataContext = userListItems;

And modify the code for the userList ListBox to look like:

<ListBox x:Name=”userList” Height=”200″ ItemsSource=”{Binding}” DisplayMemberPath=”name” />

Add a crossdomain.xml file to the rails project’s public folder:

<?xml version=”1.0″?>
<!DOCTYPE cross-domain-policy SYSTEM “http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd”>
<cross-domain-policy>
<allow-access-from domain=”*” />
</cross-domain-policy>

We are basically allowing our Silverlight app to access the rails server. You won’t be requiring this file if the Rails server is serving the Silverlight application, but currently it is not the case.

Now when you run the code you should see:

Now I will add a few more lines of code to show the selected item in TextBox. Add/Update the following to page.xaml:

<ListBox x:Name=”userList” Height=”200″ ItemsSource=”{Binding}” DisplayMemberPath=”name” SelectionChanged=”userList_SelectionChanged”/>
<StackPanel x:Name=”controls”>
<TextBox Text=”{Binding name, Mode=Twoway}” x:Name=”userName”/>
<TextBox Text=”{Binding address, Mode=Twoway}” x:Name=”userAddress”/>
</StackPanel>

The first TextBox is showing name and second is showing the password. The binding mode is set to TwoWay so that the changes in TextBox are automatically to the userListItems.

Add the corresponding event handler to Page class:

private void userList_SelectionChanged(object sender, SelectionChangedEventArgs e) {
controls.DataContext = userList.SelectedItem as User;
}

Now when you run the code you should see:

Download the code upto this point:

• Rails code
• Silverlight code

Implementing the full CRUD :

Firstly I willl be doing a bit of refactoring. Move the xml parsing code using Linq to the User class. So it should now look like:

public class User {
public int id { get; set; }
public string name { get; set; }
public string address { get; set; }

public static User[] users_from_xml(String xml_string){
XDocument users = XDocument.Parse(xml_string);
return (from x in users.Descendants(“user”)
select new User
{
id = int.Parse(x.Descendants(“id”).First().Value),
name = x.Descendants(“name”).First().Value,
address = x.Descendants(“address”).First().Value,
}).ToArray();
}

public static User user_from_xml(String xml_string) {
return users_from_xml(xml_string).First();
}
}

Change the Page class to:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;
using System.Xml.Linq;

namespace TestFrontEnd {
public partial class Page : UserControl {
private ObservableCollection<User> userListItems = new ObservableCollection<User>();

private HTTPService userIndexService;
private HTTPService userCreateService;
private HTTPService userUpdateService;
private HTTPService userDeleteService;

public Page() {
InitializeComponent();
// setting the databinding
userList.DataContext = userListItems;
controls.DataContext = new User();

// service to get all te users form the server
userIndexService = new HTTPService();
userIndexService.Url = “http://localhost:3000/users.xml”;
userIndexService.ServiceComplete += new HttpServiceCompleteEventHandler(userIndexService_ServiceComplete);
userIndexService.send();

// create a new user
userCreateService = new HTTPService();
userCreateService.Url = “http://localhost:3000/users.xml”;
userCreateService.Method = “POST”;
userCreateService.ServiceComplete += new HttpServiceCompleteEventHandler(userCreateService_ServiceComplete);

// update a user, we will not be trapping the results
userUpdateService = new HTTPService();
userUpdateService.Method = “POST”;

// delete a user
userDeleteService = new HTTPService();
userDeleteService.Method = “POST”;
}

private void _userList_SelectionChanged(object sender, SelectionChangedEventArgs e) {
controls.DataContext = userList.SelectedItem as User;
}

private void userIndexService_ServiceComplete(HttpServiceCompleteEventArgs e) {
foreach (User user in User.users_from_xml(e.Response))
userListItems.Add(user);
}
private void userCreateService_ServiceComplete(HttpServiceCompleteEventArgs e) {
userListItems.Add(User.user_from_xml(e.Response));
}

private void createButton_Click(object sender, RoutedEventArgs e) {
userCreateService.send(String.Format(“{0}={1}&{2}={3}”, “user[name]“, userName.Text, “user[address]“, userAddress.Text));
}

private void updateButton_Click(object sender, RoutedEventArgs e) {
User _selectedUser = userList.SelectedItem as User;
userUpdateService.Url = “http://localhost:3000/users/” + _selectedUser.id.ToString() + “.xml”;
userUpdateService.send(String.Format(“{0}={1}&{2}={3}&{4}={5}”, “user[name]“, userName.Text, “user[address]“, userAddress.Text, “_method”, “PUT”));
userListItems[userList.SelectedIndex] = _selectedUser;
}

private void deleteButton_Click(object sender, RoutedEventArgs e) {
User _selectedUser = userList.SelectedItem as User;
userDeleteService.Url = “http://localhost:3000/users/” + _selectedUser.id.ToString() + “.xml”;
userDeleteService.send(String.Format(“{0}={1}”, “_method”, “DELETE”));
userListItems.Remove(_selectedUser);
}

}
}

To understand the specific parameters to the “send()” method of the HTTPService class you will need a little bit of understanding of how REST is implemented in Rails and how parameters are passed to a url, which is out of scope of this blog post.

Change Page.xaml to:

<UserControl x:Class=”TestFrontEnd.Page”
xmlns=”http://schemas.microsoft.com/client/2007″
xmlns  =”http://schemas.microsoft.com/winfx/2006/xaml”
Width=”400″ Height=”300″>
<Grid x:Name=”LayoutRoot” Background=”White”>
<StackPanel Orientation=”Vertical”>
<ListBox x:Name=”userList” ItemsSource=”{Binding}” DisplayMemberPath=”name” SelectionChanged=”_userList_SelectionChanged” Height=”200″/>
<StackPanel x:Name=”controls”>
<TextBox Text=”{Binding name, Mode=Twoway}” x:Name=”userName”/>
<TextBox Text=”{Binding address, Mode=Twoway}” x:Name=”userAddress”/>
</StackPanel>
<StackPanel Orientation=”Horizontal”>
<Button Content=”Create” x:Name=”createButton” Click=”createButton_Click”/>
<Button Content=”Update” x:Name=”updateButton” Click=”updateButton_Click”/>
<Button Content=”Delete” x:Name=”deleteButton” Click=”deleteButton_Click”/>
</StackPanel>
<TextBlock x:Name=”trace” />
</StackPanel>
</Grid>
</UserControl>

This is how it looks like now:

So this is full CRUD implementation using Silverlight as frontend.

This is not the most optimal way to implement CRUD it is very easy to understand. It also should be noted that I haven’t added error checking of any type in the code and there is a lot of code repetition. But I guess that could be improved upon further once the most simple scenario is implemented. My style of coding is “First make it work and then optimize it”, and as I have mentioned it before it is certainly not the most optimized way to code but it sure works

One microsoft releases better databinding capabilities in controls and some simpler classes for HTTP based communication, this code would be much more simpler.

Full code for this aplication can be downloaded from:

Rails code

Silverlight code

del.icio.us Tags: adobe,C#,crud,flex,microsoft,rails,ruby on rails,silverlight,xaml

Rails 2.0 deprecations

The Rails core team is cleaning up. That’s obviously a good thing, however it does leave us facing a kabillion deprecation warnings when running tests and whatnot.

Unfortunately the official deprecations page appears to have been thrown together quickly after someone noticed that Rails 1.2 had been pushed out without anyone finishing the page that all deprecation warnings were referring to.

So what does a smart Rails developer who wants to be ready for Rails 2.0 when that time comes around do? She reads on…

end_form_tag is deprecated

The old, deprecated way	The new, supported way
<%= start_form_tag %> ...stuff... <%= end_form_tag %>	<% form_tag do %> ...stuff... <% end %>
<%= form_remote_tag %> ...stuff... <%= end_form_tag %>	<% form_remote_tag do %> ...stuff... <% end %>

Object transactions are deprecated

The old, deprecated way	The new, supported way
Model.transaction(foo) do ...stuff... end	Model.transaction do ...stuff... end

server_settings has been renamed smtp_settings

The old, deprecated way	The new, supported way
ActionMailer::Base.server_settings = { :address => 'my.smtp.srv' }	ActionMailer::Base.smtp_settings = { :address => 'my.smtp.srv' }

start_form_tag is deprecated

The old, deprecated way	The new, supported way
<%= start_form_tag %> ...stuff... <%= end_form_tag %>	<% form_tag do %> ...stuff... <% end %>

You called count([“field = ?”, value], nil)

The old, deprecated way	The new, supported way
model_or_association.count(['field = ?', value])	model_or_association.count(:conditions => ['field = ?', value])

You’ve called image_path with a source that doesn’t include an extension

The old, deprecated way	The new, supported way
<%= image_tag 'foo' %>	<%= image_tag 'foo.png' %>

Flex With ROR

Using Flex with Ruby on Rails

The steps needed to create the Rails application using Flex

Creating a new Flex project:

Open Flex builder and create a new Flex project.

Leave all the options to default and click Finish. A blank project is now created for you.

Add a List control to the default mxml file. It should look like:

<?xml version=”1.0″ encoding=”utf-8″?>
<mx:Application xmlns:mx=”http://www.adobe.com/2006/mxml” layout=”vertical”>
<mx:List id=”userList” width=”200″ height=”200″/>
</mx:Application>

Now create a script tag inside the source and add a Bindable element to it:

[Bindable]
private var users:XMLListCollection = new XMLListCollection();

I am using an XMLListCollection because I can easily add/remove elements from it.

Now send request to the server and bind the result to the list box:

First create a new HTTPService element:

<mx:HTTPService id=“userIndexService” resultFormat=“e4x” result=“userIndexServiceResult(event)” url=“http://localhost:3000/users.xml”/>

and handle its result:

private function userIndexServiceResult(event:ResultEvent):void{
for each(var xml:XML in event.result.user as XMLList){
users.addItem(xml);
}
}

To invoke this service we need to call its “send()” method with appropriate paramater, which in this case are none.

So the code now looks like:

<?xml version=”1.0″ encoding=”utf-8″?>
<mx:Application xmlns:mx=”http://www.adobe.com/2006/mxml” layout=”vertical” initialize=”sendServiceRequest(event)”>
<mx:Script>
<![CDATA[
import mx.rpc.events.ResultEvent;
import mx.collections.XMLListCollection;
[Bindable]
private var users:XMLListCollection = new XMLListCollection();

private function sendServiceRequest(event:Event):void{
userIndexService.send();
}
private function userIndexServiceResult(event:ResultEvent):void{
for each(var xml:XML in event.result.user as XMLList){
users.addItem(xml);
}
}
]]>
</mx:Script>
<mx:HTTPService id=”userIndexService” resultFormat=”e4x” result=”userIndexServiceResult(event)” url=”http://localhost:3000/users.xml”/>
<mx:List dataProvider=”{users}” id=”userList” width=”200″ height=”200″ labelField=”name”/>
</mx:Application>

And the output looks like:

Notice that we are sending the index request in the initialize method of the application.

Now to add controls which show the currently selected element. Its really easy. Just add the folowwing to the code and DataBinding will do the rest:

<mx:HBox>
<mx:Label text=”Name” width=”50″/>
<mx:TextInput text=”{userList.selectedItem.name}” width=”150″ id=”userName”/>
</mx:HBox>
<mx:HBox>
<mx:Label text=”Address” width=”50″/>
<mx:TextInput text=”{userList.selectedItem.address}” width=”150″ id=”userAddress”/>
</mx:HBox>

Now it loooks like:

Implementing the full CRUD:

Now we need to add the other three HTTPServices.

<mx:HTTPService id=”userIndexService” resultFormat=”e4x” result=”userIndexServiceResult(event)” url=”http://localhost:3000/users.xml”/>
<mx:HTTPService id=”userCreateService” resultFormat=”e4x” result=”userCreateServiceResult(event)” method=”POST” url=”http://localhost:3000/users.xml”/>
<mx:HTTPService id=”userUpdateService” resultFormat=”e4x” method=”POST”/>
<mx:HTTPService id=”userDeleteService” resultFormat=”e4x” method=”POST”/>

And their corresponding callbacks.

private function userCreateServiceResult(event:ResultEvent):void{
users.addItem(event.result as XML);
}

Some controls to invoke these services:

<mx:HBox>
<mx:Button label=”Create” id=”createUser” click=”sendServiceRequest(event)”/>
<mx:Button label=”Update” id=”updateUser” click=”sendServiceRequest(event)”/>
<mx:Button label=”Delete” id=”deleteUser” click=”sendServiceRequest(event)”/>
</mx:HBox>

And their event handlers (just one in this case):

private function sendServiceRequest(event:Event):void{
if(event.target.id == ‘createUser’){
userCreateService.send({‘user[name]‘: userName.text, ‘user[address]‘: userAddress.text});
}else if(event.target.id == ‘updateUser’){
userUpdateService.url = ‘http://localhost:3000/users/’+ userList.selectedItem.id +‘.xml’;
userUpdateService.send({‘user[name]‘: userName.text, ‘user[address]‘: userAddress.text, _method: ‘put’});
users[userList.selectedIndex].name = userName.text;
users[userList.selectedIndex].address = userAddress.text;
}else if(event.target.id == ‘deleteUser’){
userDeleteService.url = ‘http://localhost:3000/users/’+ userList.selectedItem.id +‘.xml’;
userDeleteService.send({_method: ‘delete’});
users.removeItemAt(userList.selectedIndex);
}else{
userIndexService.send();
}
}

Little bit of knowledge of how REST is implemented in Rails is required to understand the parameters to the “send()” method of HTTPService class is required, which is out of scope of this blog post.

The TestFrontEnd.mxml should now have the folowwing code:

<?xml version=”1.0″ encoding=”utf-8″?>
<mx:Application xmlns:mx=”http://www.adobe.com/2006/mxml” layout=”vertical” initialize=”sendServiceRequest(event)”>
<mx:Script>
<![CDATA[
import mx.collections.XMLListCollection;
import mx.controls.Alert;
import mx.rpc.events.ResultEvent;
import mx.collections.ArrayCollection;
[Bindable]
private var users:XMLListCollection = new XMLListCollection();

private function sendServiceRequest(event:Event):void{
if(event.target.id == ‘createUser’){
userCreateService.send({’user[name]‘: userName.text, ‘user[address]‘: userAddress.text});
}else if(event.target.id == ‘updateUser’){
userUpdateService.url = ‘http://localhost:3000/users/’+ userList.selectedItem.id +’.xml’;
userUpdateService.send({’user[name]‘: userName.text, ‘user[address]‘: userAddress.text, _method: ‘put’});
users[userList.selectedIndex].name = userName.text;
users[userList.selectedIndex].address = userAddress.text;
}else if(event.target.id == ‘deleteUser’){
userDeleteService.url = ‘http://localhost:3000/users/’+ userList.selectedItem.id +’.xml’;
userDeleteService.send({_method: ‘delete’});
users.removeItemAt(userList.selectedIndex);
}else{
userIndexService.send();
}
}

private function userIndexServiceResult(event:ResultEvent):void{
for each(var xml:XML in event.result.user as XMLList){
users.addItem(xml);
}
}
private function userCreateServiceResult(event:ResultEvent):void{
users.addItem(event.result as XML);
}
]]>
</mx:Script>

<mx:HTTPService id=”userIndexService” resultFormat=”e4x” result=”userIndexServiceResult(event)” url=”http://localhost:3000/users.xml”/>
<mx:HTTPService id=”userCreateService” resultFormat=”e4x” result=”userCreateServiceResult(event)” method=”POST” url=”http://localhost:3000/users.xml”/>
<mx:HTTPService id=”userUpdateService” resultFormat=”e4x” method=”POST”/>
<mx:HTTPService id=”userDeleteService” resultFormat=”e4x” method=”POST”/>

<mx:List dataProvider=”{users}” id=”userList” width=”200″ height=”200″ labelField=”name”/>

<mx:HBox>
<mx:Label text=”Name” width=”50″/>
<mx:TextInput text=”{userList.selectedItem.name}” width=”150″ id=”userName”/>
</mx:HBox>
<mx:HBox>
<mx:Label text=”Address” width=”50″/>
<mx:TextInput text=”{userList.selectedItem.address}” width=”150″ id=”userAddress”/>
</mx:HBox>
<mx:HBox>
<mx:Button label=”Create” id=”createUser” click=”sendServiceRequest(event)”/>
<mx:Button label=”Update” id=”updateUser” click=”sendServiceRequest(event)”/>
<mx:Button label=”Delete” id=”deleteUser” click=”sendServiceRequest(event)”/>
</mx:HBox>

</mx:Application>

This is the end result:

As I mentioned in my last blog post it is not the best way to make this application as there is no error handling. But I think this is the simplest way to make this application.

You also might have noticed Flex requires a lot less lines of code as compared to Silverlight. But that is also dependent on my coding approach.

Full code for this application can be downloaded from:

• Rails code
• Flex code

del.icio.us Tags: adobe,flex,mxmx,rails,ruby,ruby on rails,silverlight,xaml

Rails 2.0

 

Behold, behold, Rails 2.0 is almost here. But before we can slap on the final stamp, we’re going to pass through a couple of trial release phases. The first is this preview release, which allows you to sample the goodies in their almost finished state.

We might change a few things or add something else, but by and large, this is how Rails 2.0 is going to look and feel. After this release have had a chance to be tried out, we’re going to move to a release candidate or two (or three, depending on how many we need). Then, the final release.

Before the release of 2.0, we’re also going to be putting out 1.2.4, which will include a variety of bug fixes and the last deprecation warnings to get you ready for upgrading an existing application to 2.0 standards.

Enough about process. Let me tell you a little bit about what’s new in Rails 2.0:

Action Pack: Resources

This is where the bulk of the action for 2.0 has gone. We’ve got a slew of improvements to the RESTful lifestyle. First, we’ve dropped the semicolon for custom methods instead of the regular slash. So /people/1;edit is now /people/1/edit. We’ve also added the namespace feature to routing resources that makes it really easy to confine things like admin interfaces:

map.namespace(:admin) do |admin|

  admin.resources :products,

    :collection => { :inventory => :get },

    :member     => { :duplicate => :post },

    :has_many   => [ :tags, :images, :variants ]

end

Which will give you named routes like inventory_admin_products_url and admin_product_tags_url. To keep track of this named routes proliferation, we’ve added the “rake routes” task, which will list all the named routes created by routes.rb.

We’ve also instigated a new convention that all resource-based controllers will be plural by default. This allows a single resource to be mapped in multiple contexts and still refer to the same controller. Example:

  # /avatars/45 => AvatarsController#show

  map.resources :avatars  # /people/5/avatar => AvatarsController#show

  map.resources :people, :has_one => :avatar

Action Pack: Multiview

Alongside the improvements for resources come improvements for multiview. We already have #respond_to, but we’ve taken it a step further and made it dig into the templates. We’ve separated the format of the template from its rendering engine. So show.rhtml now becomes show.html.erb, which is the template that’ll be rendered by default for a show action that has declared format.html in its respond_to. And you can now have something like show.csv.erb, which targets text/csv, but also uses the default ERB renderer.

So the new format for templates is action.format.renderer. A few examples:

• show.erb: same show template for all formats
• index.atom.builder: uses the Builder format, previously known as rxml, to render an index action for the application/atom+xml mime type
• edit.iphone.haml: uses the custom HAML template engine (not included by default) to render an edit action for the custom Mime::IPHONE format

Speaking of the iPhone, we’ve made it easier to declare “fake” types that are only used for internal routing. Like when you want a special HTML interface just for an iPhone. All it takes is something like this:

  # should go in config/initializers/mime_types.rb

  Mime.register_alias "text/html", :iphone  class ApplicationController < ActionController::Base

    before_filter :adjust_format_for_iphone

private

      def adjust_format_for_iphone

        if request.env["HTTP_USER_AGENT"] && request.env["HTTP_USER_AGENT"][/(iPhone|iPod)/]

          request.format = :iphone

        end

      end

  end

class PostsController < ApplicationController

    def index

      respond_to do |format|

        format.html   # renders index.html.erb

        format.iphone # renders index.iphone.erb

      end

    end

  end

You’re encouraged to declare your own mime-type aliases in the config/initializers/mime_types.rb file. This file is included by default in all new applications.

Action Pack: Record identification

Piggy-backing off the new drive for resources are a number of simplifications for controller and view methods that deal with URLs. We’ve added a number of conventions for turning model classes into resource routes on the fly. Examples:

  # person is a Person object, which by convention will

  # be mapped to person_url for lookup

  redirect_to(person)

  link_to(person.name, person)

  form_for(person)

Action Pack: HTTP Loving

As you might have gathered, Action Pack in Rails 2.0 is all about getting closer with HTTP and all its glory. Resources, multiple representations, but there’s more. We’ve added a new module to work with HTTP Basic Authentication, which turns out to be a great way to do API authentication over SSL. It’s terribly simple to use. Here’s an example (there are more in ActionController::HttpAuthentication):

  class PostsController < ApplicationController

    USER_NAME, PASSWORD = "dhh", "secret"     before_filter :authenticate, :except => [ :index ]

def index

      render :text => "Everyone can see me!"

    end

def edit

      render :text => "I'm only accessible if you know the password"

    end

private

      def authenticate

        authenticate_or_request_with_http_basic do |user_name, password|

          user_name == USER_NAME && password == PASSWORD

        end

      end

  end

We’ve also made it much easier to structure your JavaScript and stylesheet files in logical units without getting clobbered by the HTTP overhead of requesting a bazillion files. Using javascript_include_tag(:all, :cache => true) will turn public/javascripts/.js into a single public/javascripts/all.js file in production, while still keeping the files separate in development, so you can work iteratively without clearing the cache.

Along the same lines, we’ve added the option to cheat browsers who don’t feel like pipelining requests on their own. If you set ActionController::Base.asset_host = “assets%d.example.com”, we’ll automatically distribute your asset calls (like image_tag) to asset1 through asset4. That allows the browser to open many more connections at a time and increases the perceived speed of your application.

Action Pack: Security

Making it even easier to create secure applications out of the box is always a pleasure and with Rails 2.0 we’re doing it from a number of fronts. Most importantly, we now ship we a built-in mechanism for dealing with CRSF attacks. By including a special token in all forms and Ajax requests, you can guard from having requests made from outside of your application. All this is turned on by default in new Rails 2.0 applications and you can very easily turn it on in your existing applications using ActionController::Base.protect_from_forgery (see ActionController::RequestForgeryProtection for more).

We’ve also made it easier to deal with XSS attacks while still allowing users to embed HTML in your pages. The old TextHelper#sanitize method has gone from a black list (very hard to keep secure) approach to a white list approach. If you’re already using sanitize, you’ll automatically be granted better protection. You can tweak the tags that are allowed by default with sanitize as well. See TextHelper#sanitize for details.

Finally, we’ve added support for HTTP only cookies. They are not yet supported by all browsers, but you can use them where they are.

Action Pack: Exception handling

Lots of common exceptions would do better to be rescued at a shared level rather than per action. This has always been possible by overwriting rescue_action_in_public, but then you had to roll out your own case statement and call super. Bah. So now we have a class level macro called rescue_from, which you can use to declaratively point certain exceptions to a given action. Example:

  class PostsController < ApplicationController

    rescue_from User::NotAuthorized, :with => :deny_access    protected

      def deny_access

        ...

      end

  end

Action Pack: Miscellaneous

Also of note is AtomFeedHelper, which makes it even simpler to create Atom feeds using an enhanced Builder syntax. Simple example:

  # index.atom.builder:

  atom_feed do |feed|

    feed.title("My great blog!")

    feed.updated((@posts.first.created_at))    for post in @posts

      feed.entry(post) do |entry|

        entry.title(post.title)

        entry.content(post.body, :type => 'html')

entry.author do |author|

          author.name("DHH")

        end

      end

    end

  end

We’ve made a number of performance improvements, so asset tag calls are now much cheaper and we’re caching simple named routes, making them much faster too.

Finally, we’ve kicked out in_place_editor and autocomplete_for into plugins that live on the official Rails SVN.

Active Record: Performance

Active Record has seen a gazillion fixes and small tweaks, but it’s somewhat light on big new features. Something new that we have added, though, is a very simple Query Cache, which will recognize similar SQL calls from within the same request and return the cached result. This is especially nice for N+1 situations that might be hard to handle with :include or other mechanisms. We’ve also drastically improved the performance of fixtures, which makes most test suites based on normal fixture use be 50-100% faster.

Active Record: Sexy migrations

There’s a new alternative format for declaring migrations in a slightly more efficient format. Before you’d write:

create_table :people do |t|

  t.column, "account_id",  :integer

  t.column, "first_name",  :string, :null => false

  t.column, "last_name",   :string, :null => false

  t.column, "description", :text

  t.column, "created_at",  :datetime

  t.column, "updated_at",  :datetime

end

Now you can write:

create_table :people do |t|

  t.integer :account_id

  t.string  :first_name, :last_name, :null => false

  t.text    :description

  t.timestamps

end

Active Record: XML in, JSON out

Active Record has supported serialization to XML for a while. In 2.0 we’ve added deserialization too, so you can say Person.new.from_xml(“
David“) and get what you’d expect. We’ve also added serialization to JSON, which supports the same syntax as XML serialization (including nested associations). Just do person.to_json and you’re ready to roll.

Active Record: Shedding some weight

To make Active Record a little leaner and meaner, we’ve removed the acts_as_XYZ features and put them into individual plugins on the Rails SVN repository. So say you’re using acts_as_list, you just need to do ./script/plugin install acts_as_list and everything will move along like nothing ever happened.

A little more drastic, we’ve also pushed all the commercial database adapters into their own gems. So Rails now only ships with adapters for MySQL, SQLite, and PostgreSQL. These are the databases that we have easy and willing access to test on. But that doesn’t mean the commercial databases are left out in the cold. Rather, they’ve now been set free to have an independent release schedule from the main Rails distribution. And that’s probably a good thing as the commercial databases tend to require a lot more exceptions and hoop jumping on a regular basis to work well.

The commercial database adapters now live in gems that all follow the same naming convention: activerecord-XYZ-adapter. So if you gem install activerecord-oracle-adapter, you’ll instantly have Oracle available as an adapter choice in all the Rails applications on that machine. You won’t have to change a single line in your applications to take use of it.

That also means it’ll be easier for new database adapters to gain traction in the Rails world. As long as you package your adapter according to the published conventions, users just have to install the gem and they’re ready to roll.

Active Record: with_scope with a dash of syntactic vinegar

ActiveRecord::Base.with_scope has gone protected to discourage people from misusing it in controllers (especially in filters). Instead, it’s now encouraged that you only use it within the model itself. That’s what it was designed for and where it logically remains a good fit. But of course, this is all about encouraging and discouraging. If you’ve weighed the pros and the cons and still want to use with_scope outside of the model, you can always call it through .send(:with_scope).

ActionWebService out, ActiveResource in

It’ll probably come as no surprise that Rails has picked a side in the SOAP vs REST debate. Unless you absolutely have to use SOAP for integration purposes, we strongly discourage you from doing so. As a naturally extension of that, we’ve pulled ActionWebService from the default bundle. It’s only a gem install actionwebservice away, but it sends an important message none the less.

At the same time, we’ve pulled the new ActiveResource framework out of beta and into the default bundle. ActiveResource is like ActiveRecord, but for resources. It follows a similar API and is configured to Just Work with Rails applications using the resource-driven approach. For example, a vanilla scaffold will be accessible by ActiveResource.

ActiveSupport

There’s not all that much new in ActiveSupport. We’ve a host of new methods like Array#rand for getting a random element from an array, Hash#except to filter down a hash from undesired keys and lots of extensions for Date. We also made testing a little nicer with assert_difference. Short of that, it’s pretty much just fixes and tweaks.

Action Mailer

This is a very modest update for Action Mailer. Besides a handful of bug fixes, we’ve added the option to register alternative template engines and assert_emails to the testing suite, which works like this:

1. Assert number of emails delivered within a block: assert_emails 1 do post :signup, :name => ‘Jonathan’ end

Rails: The debugger is back

To tie it all together, we have a stream of improvements for Rails in general. My favorite amongst these is the return of the breakpoint in form of the debugger. It’s a real debugger too, not just an IRB dump. You can step back and forth, list your current position, and much more. It’s all coming from the gracious note of the ruby-debug gem. So you’ll have to install that for the new debugger to work.

To use the debugger, you just install the gem, put “debugger” somewhere in your application, and then start the server with—debugger or -u. When the code executes the debugger command, you’ll have it available straight in the terminal running the server. No need for script/breakpointer or anything else. You can use the debugger in your tests too.

Rails: Clean up your environment

Before Rails 2.0, config/environment.rb files every where would be clogged with all sorts of one-off configuration details. Now you can gather those elements in self-contained files and put them under config/initializers and they’ll automatically be loaded. New Rails 2.0 applications ship with two examples in form of inflections.rb (for your own pluralization rules) and mime_types.rb (for your own mime types). This should ensure that you need to keep nothing but the default in config/environment.rb.

Rails: Easier plugin order

Now that we’ve yanked out a fair amount of stuff from Rails and into plugins, you might well have other plugins that depend on this functionality. This can require that you load, say, acts_as_list before your own acts_as_extra_cool_list plugin in order for the latter to extend the former.

Before, this required that you named all your plugins in config.plugins. Major hassle when all you wanted to say was “I only care about acts_as_list being loaded before everything else”. Now you can do exactly that with config.plugins = [ :acts_as_list, :all ].

And hundreds upon hundreds of other improvements

What I’ve talked about above is but a tiny sliver of the full 2.0 package. We’ve got literally hundreds of bug fixes, tweaks, and feature enhancements crammed into Rails 2.0. All this coming off the work of tons of eager contributors working tirelessly to improve the framework in small, but important ways.

I encourage you to scourger the CHANGELOGs and learn more about all that changed.

So how do I upgrade?

If you want to move your application to Rails 2.0, you should first move it to Rails 1.2.3. That’ll include deprecation warnings for most everything we yanked out in 2.0. So if your application runs fine on 1.2.3 with no deprecation warnings, there’s a good chance that it’ll run straight up on 2.0. Of course, if you’re using, say, pagination, you’ll need to install the classic_pagination plugin. If you’re using Oracle, you’ll need to install the activerecord-oracle-adapter gem. And so on and so forth for all the extractions.

To install the preview release through gems, do:

gem install rails --source http://gems.rubyonrails.org

To try it from an SVN tag, use:

rake rails:freeze:edge TAG=rel_2-0-0_PR

We’ll also be putting out Rails 1.2.4 shortly which will include a few more deprecations to warn you in time for 2.0.

In any case, as I explained in the beginning, this is a preview release. Use it to get a feel for 2.0. See where your currently application might need tweaks. And try creating a new application from scratch to see the new defaults. In a few weeks we’ll get on with the release candidates.

Thanks to everyone who’ve been involved with the development of Rails 2.0. We’ve been working on this for more than six months and it’s great finally to be able to share it with a larger audience. Enjoy!

Comments

regards

M.K.Jeevika