Rails Basics

February 10, 2008 – 2:09 pm

What would a community site be without the basics? I know there are many sites out there with how to set things up but if you happened to come across my site first, Iíll be happy to lead you in the right direction.

Step 1 ñ Installation

For installation there is no better site then:

www.RubyOnRails.org

Follow the directions and you should have the rails environment setup in very little time.

Step 2 ñ IDE

For me, comin from the java world, I need an IDE that helps with syntax as much as possible. This is a bad habbit and the scripting programmers laugh at how much we need an IDE to write software, but to me its just more efficient. There are 2 IDEs I have used and would recomment.

RadRails

This IDE is based on eclipse and has the essential features you would need in an IDE. The only problem is the auto-completion is kind of lacking at this point in time, and to me, autocompletion is a dream to have in an IDE.

JEdit

This is a very basic text editor but it has plugins that will allow it to have autocompletion for ruby code. This is extremely helpful. It also has the ability to have macros/shortcuts to quickly put together commonly used ruby commands. The downside, it does not manage projects very well. There is a plugin to allow you to ëgroupí together files into a ëprojectí but it is nothing like eclipse in the way it creates ëprojects.

As for the winner, you decide.

Step 3 ñ Tutorials!

For me the best way to learn is to jump right in. There are some really great basic tutorials out there to help get you started. Here is a list of the ones I have learned from myself.

Step 4 ñ Create

You are on your own for this one. Make Apps, ask questions, learn and grow. I will be creating my own more advanced tutorials as I begin to try to recreate Java apps that I have developed previously into Rails Apps. I want to test how well they do versus eachother in real world examples.

Enjoy and welcome to the world of rails!

Posted in Rails | No Comments »

Single Table Inheritance Tricks

February 9, 2008 – 12:40 pm

Single Table Inheritance Tricks..

Single table inheritance is an extremely powerful and extremely easy thing to do in rails. If you wanted to do this in java you would probably shoot yourself just designing it, but all that pain is relieved inside the wonderful rails framework.

The Scenario

You have the need for users to log into your system with different roles and each of these different roles can have different permissions. But these roles also can have things in common and share permissions. You could add a column into the table called ‘role’ and then do if(role==”admin”) to determine what permissions you should do. But there is an easier solution. Single Table Inheritance.

The Table

First you would create a table called User and put in your common columns eg.

CREATE TABLE `users` (

`id` int(11) NOT NULL auto_increment,

`manager_id` int(11) default NULL,

`first_name` varchar(255) default NULL,

`last_name` varchar(255) default NULL,

`type` varchar(255) default NULL,

`user_name` varchar(255) default NULL,

`hash_password` varchar(255) default NULL,

`email` varchar(255) default NULL,

`parent_id` int(11) default NULL,

`created_on` date default NULL,

PRIMARY KEY (`id`)

)

The important column in this Single Table Inheritance is the type column. This column must be a string because what Rails does is it fills this column with the class name.

The Model

The model that goes along with this table is the User model. Now we want to create an Admin model. Admins have the same characteristics of Users, but have different permissions and abilities. To do this all you have to do is extend the User class instead of the ActiveRecord::Base class.

class Admin < User

end

Now you have the power to do calls like Admin.find_all and it will only grab the Admin users. But if you did User.find_all it would include admins in the query. Now you can add methods in the Admin class that are specific for that class only. You can build your permissions into those methods instead of having to dig permissions out of the base User object. You can also take this further. Say you have 3 classes, a User, a Manager, and an Admin. The user has no permissions, the manager has some permissions, and the Admin has both the managers permissions and its own. The way you would do this is to have managers extend user, and Admins extend Manager. All of this is kept in the same table so there is no need to change anything in the database.

Tricks with Extending many classes

there are a few things you can do to help this process out. In the previous scenario if i wanted to use the same ‘create’ page, I would have to determine what class of user I wanted to create before I saved it. This is a helpful method to put in your User class to help.

def self.factory(type,params)

type ||= ‘User’

class_name = type

if defined? class_name.constantize

return class_name.constantize.new(params)

else

User.new(params) # or do what you will…

end

end

Now when you want to create a user you would do put a role paramter in your page so that the controller can determine what you want:

@user = User.factory(params[:user][:role], params[:user])

@user.save

Another important trick is if you wanted to change that users class or want to know what kind of class he is for display purposes. You would do this by putting these getter and setter methods inside of your User model.

def class_type=(value)

self[:type] = value

end

def class_type

return self[:type]

end

So if you wanted to make a manager into an admin all you would do is @manager.class_type=”Admin” and he would magically become an admin.

Hope these tips helped. Leave comments if you have any other suggestions or find a flaw with this tutorial.

Posted in Rails | No Comments »

Copyright The Art of Rails 2008 Entries (RSS) and Comments (RSS).