Maulana Ruby

Getting started with engines development in rails 2.3

hasham2006 — Wed, 04 Feb 2009 19:26:15 +0000

Rails 2.3 RC1 has just been released. There are number of new features like application templates, Metal points, Rack integration and support for Engines. Earlier engines plugins were not in much favour. But now since merb has similar feature in form of slices they have recently been back in favour and now the engines have made it to core. but not all feature has been ported as pointed out by post on rails engines site.

Lets get started with developing a simple plugin that uses engines feature of rails 2.3 RC1. This tutorial is based on rails flickr demo application. lets install latest 2.3 gems on your machine.

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

Lets generate empty rails application and run plugin generator. There is no seperate generator for engines as engine plugin is type of plugin. Lets call our plugin flickr_search from application root issue this command

$ script/generate plugin flickr_search

This will generate a flickr_search folder in vendor/plugin which contains whole bunch of files which is empty skeleton for new plugin. since our plugin is based on flickr api you need to install flickr gem and get API key from http://www.flickr.com/services/api/misc.api_keys.html.

$ sudo gem install flickr

Now edit init.rb file in flickr_search folder and write out this code. Make sure you replace your API key in code

require 'rubygems' require 'flickr' MY_KEY='Enter your Flicker API Key' class Flickr alias old_initialize initialize def initialize(api_key=MY_KEY, email=nil, password=nil) puts "new_initialize " + MY_KEY old_initialize(api_key, email, password) @host="http://api.flickr.com" @activity_file='flickr_activity_cache.xml' end end

With engines support in rails you can have same app folders in your plugin as well. so lets create app folder in flickr_search folder also create sub folders like controller, views, models and helpers as in any rails application. Lets create a controller file in controllers folder called flickr_controller.rb and create index action. Noew in views folder create layout folder and add layout file called flickrlayout.html.erb. Add this code to layout
Flickr <%= javascript_include_tag :defaults %> <%= stylesheet_link_tag 'flickr' %> <%= yield %>

Notice that the code has some asset helpers. currently rails does not have support for seperate assets for plugin so we need to copy these style sheets and other assets to rails public directory. This can easily be done by writing few lines of code in install.rb file. but in our case we will simply create flickr.css file in public/stylesheets directory of main rails application. so lets create this file and copy these styles in it.

body { background-color: #888; font-family: Lucida Grande; font-size: 11px; margin: 25px; }


form {

margin: 0;

margin-bottom: 10px;

background-color: rgb(222,231,236);

border: 5px solid #333;

padding: 25px;

}
fieldset {

border: none;

}
#spinner {

float: right;

margin: 10px;

}

#photos img { border: 1px solid #000; width: 75px; height: 75px; margin: 5px; }

Lets create a view for searching flickr images. In app/views directory of you plugin create index.html.erb file. Copy this code in it

<% form_remote_tag :url => {:action => 'search'}, :update => 'photos' do %>



Tags:
<%= text_field_tag 'tags' %>

<%= submit_tag 'Find' %>




<% end %>

Create a search action in flickr_controller.rb file that gets called by AJAX action in index.html.erb view. Now your controller code should look like this

class FlickrController < ApplicationController


layout "flickrlayout"
def index

end
def search

flickr = Flickr.new
if params[:tags].empty?

render :text => '
Please enter a search string
'

else

begin

photos = flickr.photos(:tags => params[:tags], :per_page => '24')

render :partial => 'photo', :collection => photos

rescue NoMethodError

render :text => 'No matching photos found
'

end

end

end

end

Also create _photo.html.erb partial in views/flickr folder. this will contain this line of code

">

With engine you can also add routes with routes.rb file. so lets create config folder in plugin root folder and add routes.rb file. you can add custom route for flickr search here

ActionController::Routing::Routes.draw do |map| map.pics '/pics', :controller => 'flickr' end

Now go ahead and run your application the flickr search should be working on http://0.0.0.0:3000/pics

One thing about migrations there is still no way to have seperate migration in engines plugin you would still need to generate and copy migrations to main applications db/migrate folder.

What you think about merger of merb and rails

hasham2006 — Fri, 02 Jan 2009 11:29:02 +0000

I think that development of merb should continue independently as well. what do you think?

View This Poll

First version of rails with threat safety is here

hasham2006 — Sat, 22 Nov 2008 15:14:15 +0000

Rails 2.2 was released yesterday which happens to be first version to support thread safety. Previously lack of threads in rails has been cause of scalabilty concerns especially with twitter problems coming to limelight. So new version of rails will solve these issue? “Not so fast!” says most of people in ruby community.

One of the main reasons why not all new rails application will become multi threaded overnight is native libraries (i.e mysql client library etc). All most all rails applications use these libraries and these libraries block ruby intrpreter from calling these libraries with multiple threads. One answer to this problem is Mysql Plus library which uses never block api.

Another issue with rails multi threading is that it is being added as after thought and has not been extensively tested. if you really has to develop multi threaded ruby web application i think you should go with merb. The merb 1.0 was recently released as well. There are some open source multi threaded applications already out there.

Another issue threads support in Ruby VM. Current Ruby 1.8 VM does not support native threads but next version of Ruby 1.9 VM will support native threads. JRuby VM currently has much more support for threading and it is expected that both Merb and future version of Rails will have great performance and scalibility on JRuby VM. Upcoming Java 7 Runtime will have additional support for hosted dynamic languages like JRuby and Jython which will address many concerns about performance of JVM hosted languages like Groovy, Scala and JRuby.

Simplicant Goes into Public Beta

hasham2006 — Mon, 21 Apr 2008 12:46:17 +0000

The public beta of Simplicant was officially released few days ago. As a follow up to my previous post . Here is some details according to official press release.

Simplicant allows SMEs to move towards a more organized, cleaner job applications management system. simplicant is the first web 2.0 applicant tracking system and brings the spirit of web 2.0 into hiring. It is completely web-based (Software as a Service) and makes use of powerful web 2.0 concepts like tags, rankings, search and collaboration to make the hiring experience easier, smoother and quicker.

Here is link to official press release:

Simplicant Goes into Public Beta

Tags: RubyLanguage, Ruby on rails, Web 2.0

BitNami JRubyStack makes JRuby on Rails setup simple

hasham2006 — Tue, 18 Mar 2008 07:43:42 +0000

BitNami JRubyStack makes JRuby on Rails setup simple. The stack comes bundled with JRuby, Rails, Tomcat, Glassfish Gem, Mysql and Subversion. You can run your Rails app either with Glassfish or make a war and deloy to tomcat. The whole package is distributed under Apache 2.0 License.

There has been few sites that use JRuby proving that JRuby does scale. Thoughtworks project management application mingle is powered by JRuby and Rails. Sun mediacast site is also now running on JRuby and Rails

Tags: jruby, Rails

Matz talks about Ruby 1.9 (Yarv)

hasham2006 — Tue, 18 Mar 2008 06:41:07 +0000

Matz talks about new Ruby version. Ruby 1.9 beta was released on christmas day at 25 december 2007.
Matz presents about new ruby version at google conference. The new version was earlier known as Yet Another Ruby Virtual machine (YARV). The main feature of Ruby 1.9 is support for platform threads. The Tread class in earlier Ruby VM’s were green threads.

Simplicant Public Beta will be launched soon

hasham2006 — Sat, 08 Sep 2007 09:02:45 +0000

It has been almost an year since my first Ruby on Rails project was launced as private beta. The Simplicant is simplest web based applicant tracking system. Based on years of experience in hiring of medium and small companies, simplicant gives you headstart when you want hire applicants in your comapnies. This Applicant tracking system not only allows you to post jobs on job board and recieve resumes, but also allows you to ask questions before you interview the applicant. After interview simplicant allows you to communicate with applicants

Simplicant has been totally overhauled for performance and scalability. The web based interface has features that are found in todays Web 2.0 applications.

The company behind Simplicant is confiz solutions which is known for developing many of todays major Web 2.0 apps. The new public beta for will be launched soon.

Rubinus – Smalltalk inspired Ruby VM

hasham2006 — Wed, 01 Aug 2007 06:07:13 +0000

Borrowing ideas from smalltalk-80 Evan Phoenix (of EngineYard) has created a new Ruby VM. The VM is written in C with Ruby like syntax. Language known as Garnet (formerly known as Cuby). Most parts of VM are written in Ruby itself except GC , Core VM (opcodes) and Primitives which are written in Garnet.

The link to InfoQ article is:

http://www.infoq.com/news/2007/07/rubinius-interview-part-one

Also look at Ruby VM performance shootout here:

http://www.oreillynet.com/ruby/blog/2007/02/fascinating_ruby_implementatio.html

STI vs. Polymorphic association

hasham2006 — Sat, 17 Feb 2007 08:51:22 +0000

This is a common to have join between two tables based on condition. suppose we have table in database called comments and we can have comments on different thing like a video, profile or picture. So keeping DRY (Don’t repeat yourself) principle in mind while designing your database. You may want to have relationship between single comments table and videos or profiles table.

At database level you should have two fields in table one field (i.e. type) that identifies the type of comment whether it is a comment on video or it’s a comment on profile, and another field (i.e source_id) that contains id of the video or profile that comment was on.

In Ruby on Rails currently there are two ways to define this kind of association between your activerecord models:

Single Table Inheritance:

Here you ‘ll create a single table of comments and Comment AR class, there would be two additional classes ProfileComment and VideoComment inheriting from same Comment AR class. Instead of having association between Profile and Comment model there would be association between Profile and ProfileComment subclass. Same will be the case with Video model and VideoComment subclass.

If we take a look at comment table we ‘ll see that class name for each record will be automatically stored in type field. The reference to associated table would be in source_id field.

class Comment < ActiveRecord::Base end class VideoComment < Comment belongs_to :video, :foreign_key => "source_id" end class ProfileComment < Comment belongs_to :profile, :foreign_key => "source_id" end
Polymorphic Association:

Since Rails 1.1 there is a simpler way to create this kind of relationship called polymorphic association. In case of polymorphic association you ‘ll have two fields called commentable_type and commentable_id, instead of type and source_id. The commentable_type field will store name of class which that instance relates to and commentable_id saves the reference to instance of that class. The relations will be created like this:

class Comment < ActiveRecord::Base belongs_to :commentable, :polymorphic => true end class Video < ActiveRecord::Base has_many :comments, :as => :commentable end class Profile < ActiveRecord::Base has_many :comments, :as => :commentable end

Pros and Cons:

The STI approach offers more flexibilty by allowing you to have additional fields that only have value in case of one sub class. For access from other sub class can be disallowed be overridden accessors.
The STI requires you to create a seperate class to implement a relation between two models, resulting in more classses. which is not case with polymorphic association
The STI results in more code.It is confusing to some programmers to understand relation between STI classes
The polymorphic association is very easy to implement.

Migrate command in Rails 1.2

hasham2006 — Fri, 09 Feb 2007 20:14:39 +0000

The usual migrate command syntax of

rake migrate VERSION=x

throws a warning informing the user that the command is deprecated, the new command syntax is

rake db:migrate

look at other depreciations in rails 1.2 at

http://www.railtie.net/articles/2006/11/02/deprecations-in-rails-1-2