Advanced Rails offers you an in-depth look at techniques for dealing with databases, security, performance, web services and much more.

O’Reilly Media, Inc. published an intermediate-to-expert Rails book, authored by Brad Ediger:

Chapters in this book help you understand not only the tricks and techniques used within the Rails framework itself, but also how to make use of ideas borrowed from other programming paradigms. Advanced Rails pays particular attention to building applications that scale — whether “scale” means handling more users, or working with a bigger and more complex database.

You’ll find plenty of examples and code samples that explain:

• Aspects of Ruby that are often confusing or misunderstood
• Metaprogramming
• How to develop Rails plug-ins Different database management systems
• Advanced database features, including triggers, rules, and stored procedures
• How to connect to multiple databases
• When to use the Active Support library for generic, reusable functions Security principles for web application design, and security issues endemic to the Web When and when not to optimize performance
• Why version control and issue tracking systems are essential to any large or long-lived Rails project
• Advanced Rails also gives you a look at REST for developing web services, ways to incorporate and extend Rails, how to use internationalization, and many other topics.

Advanced Rails is an essential resource for improving your skills on Rails through advanced techniques.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

A common stumbling block for beginner Rails developers is learning the basics required to write plugins. This is made more complicated by the fact that Ruby is inherently dynamic and offers many techniques for code reuse.

Luckily, if you can write Rails applications you can write plugins by simply drawing on a handful of basic patterns.

Why write plugins?

Writing a plugin will:

• Help make sharing code more efficient, whether it’s between projects or within the same project
• Allow you to publish generic code to the community
• Save time and increase your confidence by testing once and reusing many times
• Share functionality in a robust manner, especially when using namespaces with ActiveRecord

Usage

Rails provides installation scripts through script/plugin install, and a generator for creating new plugins: script/generate plugin. These will work with URLs, saving time when trying out plugins. You can read more about installing and managing plugins at the Rails wiki.

Rubyisms

Any of the following tools and techniques provided by Ruby are used by plugins to extend functionality:

• Mixins: including or extending classes using modules
• Opening a class or module definition and adding or overriding methods
• Dynamic extension through callbacks and hooks: method_missing, Class#inherited, Module#const_missing, Module#included
• Dynamic extension through code generation: eval, class_eval, instance_eval

These techniques fall into two broad categories:

• Using modules and classes to extend existing classes, providing new features
• Using introspection to adapt generic code to specific cases

It’s important to consider exactly what should be extended when writing a plugin. If complex meta-programming to adapt your plugin to the host application is required, care should be taken to ensure concurrency will not produce unexpected results.

Hopefully this very short summary clears things a bit. Read more on Alex Young’s article.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

As easy as:
has_timezone :fields => [ :start_datetime, :end_datetime]
Timezone_fu makes it really easy to deal with datetime fields in your models. It adds a method to your models, has_timezone.

The README for the plugin describes all of the options but below is an example:

class Event < ActiveRecord::Base
    has_timezone :fields => [ :start_datetime, :end_datetime]
end

The model has three fields a start_datetime and end_datetime and a timezone. Adding has_timezone to the model changes the behavior of the two datetime attributes.
Notice below that calling event.start_datetime shows the time in local time (”America/New York”).

>> event = Event.find(:first)=> #<Event:0×1b71b40 @attributes={
       “end_datetime”   => “2007-11-21 15:00:00″,
      “start_datetime” => “2007-11-21 14:15:00″,
      “timezone”       => “America/New_York”}
>> event.start_datetime
=> Wed Nov 21 09:15:00 UTC 2007
>> event.display_start_datetime
=> “Nov. 21, 2007 09:15 AM”
>> event.utc_start_datetime
=> Wed Nov 21 14:15:00 UTC 2007

You can also set the value of the field to a local date/time and it will be converted to UTC automatically:

>> event.start_datetime = Time.now
=> Sun Nov 25 06:26:35 +0000 2007
=> #<Biz::Event:0×1b71b40 @attributes={
  “end_datetime”    =>  “2007-11-21 15:00:00″
  “start_datetime”  =>  Sun Nov 25 11:26:35 +0000 2007,
  “timezone”        =>  “America/New_York” } 

If you want to access the fields and retrieve the database value you can use the utc_field_name method to access the UTC value of the attribute. The plugin makes a couple of core assumptions. One it assumes that the default rails timezone is UTC:

ENV[‘TZ’] = ‘UTC’

Second it assumes that the model has a timezone attribute named timezone:

t.column :timezone, :string, :default => ”

Read more on: hackd.wordpress homepage.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

We’ve been doing a lot of scraping and mashups lately. So we’d love to share on how to do this. Fortunately Schadenfreude has written a good tutorial about using Mechanize and Hpricot to scrape Gmail.

The tutorial uses mechanize and hpricot to login to gmail and return a list of Unread emails.

Installation of required tools

gem install mechanize --include-dependencies


This will install both mechanize and hpricot.

Usage

Before we can scrape our gmail account, we will need to login. Mechanize is a lib for “automating interaction with websites”. It can store and send cookies as well so once we login our script will now have a session to putter around in as if it was a web browser.

require 'rubygems'
require 'mechanize'

agent = WWW::Mechanize.new
page = agent.get 'http://www.gmail.com'

form = page.forms.first
form.Email = '***your gmail account***'
form.Passwd = '***your password***'

page = agent.submit form

After logging in gmail will try to redirect us to http://mail.google.com/mail?ui&auth=DC8F…. we need to follow this link. Using hpricot we can search for the meta redirect and grab the href attribute then have mechanize follow the link.

page = agent.get page.search("//meta").first.attributes['href'].gsub(/'/,'')

Note we need to strip the single quotes from around the url, i used gsub for this.

The returned page will try to use javascript to load the interface but it will not work for use. Thankfully a noscript tag is included in the source and contains a helpful clue.

<noscript><font face="arial">JavaScript must be enabled in order for you to use Gmail in standard view.
However, it seems JavaScript is either disabled or not supported by your browser.
To use standard view, enable JavaScript by changing your browser options, then <a href="">try again</a>.

<p>To use Gmail's basic HTML view, which does not require JavaScript,
<a href="?ui=html&zy=n">click here</a>.</p></font>

<p><font face="arial">If you want to view Gmail on a mobile phone or similar device
<a href="?ui=mobile&zyp=n">click here</a>.</font></p></noscript>

Full source

require 'rubygems'
require 'mechanize'

agent = WWW::Mechanize.new

page = agent.get 'http://www.gmail.com'
form = page.forms.first
form.Email = '***your gmail account***'
form.Passwd = '***your password***'
page = agent.submit form

page = agent.get page.search("//meta").first.attributes['href'].gsub(/'/,'')
page = agent.get page.uri.to_s.sub(/\?.*$/, "?ui=html&zy=n")
page.search("//tr[@bgcolor='#ffffff']")  do |row|
from, subject = *row.search("//b/text()")
url = page.uri.to_s.sub(/ui.*$/, row.search("//a").first.attributes["href"])
puts "From: #{from}\nSubject: #{subject}\nLink: #{url}\n\n"

email = agent.get url
# ..
end

Enjoy the tutorial!

Read more on Schadenfreude.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

ActiveScaffold is a plugin for Ruby on Rails (also known as Rails) that provides dynamic model-based view generation. Instead of having to create pages by hand that display your models, ActiveScaffold will introspect your ActiveRecord models and dynamically generate a CRUD (create, read, update, delete) user interface for managing those objects.

Installing ActiveScaffold

As ActiveScaffold is a Rails plugin, you can install it from a remote Web or Subversion server. The command below will check out the ActiveScaffold plugin from the ActiveScaffold Subversion server.

Install the latest version of the plugin:

script/plugin install http://activescaffold.googlecode.com/svn/tags/active_scaffold

Add this to your layout:

<%= javascript_include_tag :defaults %>
<%= active_scaffold_includes %>

Add this to your controller:

active_scaffold :<your_model_name>

for example:

class UsersController < ApplicationController
  active_scaffold :user
end

That’s it! Your first ActiveScaffold is up and running.

The Model

Most modern Web application frameworks are based on the MVC (model, view, controller) pattern, and Rails is no different. The model represents the data stored in the database with each table having a corresponding ActiveRecord model class in Ruby.

class User < ActiveRecord::Base
   belongs_to  rganization
end
class Organization < ActiveRecord::Base
  has_many :projects
  has_many :users
end
class Project < ActiveRecord::Base
  belongs_to  rganization
  has_many :projects_users
  has_many :administrators, :through => :projects_users, :source => :user,
           :conditions => "projects_users.role_type = 3"
  has_many :managers, :through => :projects_users, :source => :user,
           :conditions => "projects_users.role_type = 2"
  has_many :workers, :through => :projects_users, :source => :user,
           :conditions => "projects_users.role_type = 1"
end
class ProjectsUser < ActiveRecord::Base
  belongs_to :project
  belongs_to :user
end

Visit ActiveScaffold home page to find out more!

P.S.: Happy New Year from AdaRuby.com crew (Hendy & Eka)!

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Using jRails, you can get all of the same default Rails helpers for javascript functionality using the lighter jQuery library.

jRails is a drop-in jQuery replacement for Prototype/script.aculo.us on Rails. It has the features and the visual effect.The visual effects in jRails are based on the new jquery-fx library. jRails currently uses a slightly modified version of jquery fx code to get some of the desired effects.

Features of jRails :

jRails provides drop-in functionality for these existing Rails methods.

• • Scriptaculous
  • draggable_element
  • drop_receiving_element
  • sortable_element
  • visual_effect
• • RJS
  • hide
  • insert_html
  • remove
  • replace
  • replace_html
  • show
  • toggle

How to use it?

Just install and go! Once installed, the previous Prototype/script.aculo.us helpers will be replaced by jQuery ones. In order for them to function correctly, just include the appropriate javascript files in the head of your page.

 

<script src="/javascripts/jquery.js" type="text/javascript"></script>
<script src="/javascripts/jquery-ui.js" type="text/javascript"></script>
<script src="/javascripts/jquery-fx.js" type="text/javascript"></script>
<script src="/javascripts/jrails.js" type="text/javascript"></script>

You can also use the Rails javascript_include_tag helper with :default to load them automagically.

 

<%= javascript_include_tag :defaults %>

Visit jRails home page to find out more!

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Selenium Core provides an easy way to test Rails application.

This plugin does four things:

1. The Selenium Core files don‘t have to pollute /public.
2. No need to create suite files, they are generated on the fly — one suite per directory in /test/selenium (suites can be nested).
3. Instead of writing the test cases in HTML you can use a number of better formats (see Formats).
4. Loading of fixtures and wiping of session (/selenium/setup).

Installation

1. Install Selenium on Rails: script/plugin install http://svn.openqa.org/svn/selenium-on-rails/selenium-on-rails
2. If you‘re on Windows, gem install win32-open3
3. If the RedCloth gem is available the Selenese test cases can use it for better markup.
4. Run the Rakefile in the plugin‘s directory to run the tests in order to see that everything works. (If RedCloth isn‘t installed a few tests will fail since they assume RedCloth is installed.)
5. Create a test case: script/generate selenium login
6. Start the server: script/server -e test
7. Point your browser to localhost:3000/selenium
8. If everything works as expected you should see the Selenium test runner. The north east frame contains all your test cases (just one for now), and the north frame contains your test case.

Formats

The test cases can be written in a number of formats. which one you choose is a matter of taste. You can generate your test files by running sript/generate selenium or by creating them manually in your /test/selenium directory.

• Selenese, .Sel

Selenese is the dumbest format (in a good way). You just write your commands delimited by | characters.

 |open|/selenium/setup|
 |open|/|
 |goBack|

If you don‘t want to write Selenese tests by hand you can use SeleniumIDE which has support for Selenese.

SeleniumIDE makes it super easy to record test and edit them.

• RSelenese, .rSel

RSelenese enable you to write your tests in Ruby.

 setup :fixtures => :all
 open '/'
 assert_title 'Home'
 ('a'..'z').each {|c| open :controller => 'user', :action => 'create', :name => c }

See SeleniumOnRails::TestBuilder for available commands.

Configuration

There are a number of settings available. You make them by renaming config.yml.example to config.yml and make your changes in that file.

• Environment

Per default this plugin is only available in test environment. You can change this by setting environments, such as:

 #config.yml
 environments:
   - test
   - development

• Selenium Core Path

If you don‘t want to use the bundled Selenium Core version you can set selenium_path to the directory where Selenium Core is stored.

 #config.yml
 selenium_path: 'c:selenium'

Test Acceptance

You can run all your Selenium tests as a Rake task. First, if you‘re on Windows, you have to make sure win32-open3 is installed. Then you have to configure which browsers you want to run, like this:

#config.yml browsers: firefox: ‘c:\Program Files\Mozilla Firefox\firefox.exe’ ie: ‘c:\Program Files\Internet Explorer\iexplore.exe’ Now you‘re all set. First start a server:

script/server -e test Then run the tests:

rake test:acceptance Now it should work, otherwise let me know!

Store results

If you want to store the results from a test:acceptance you just need to set in which directory they should be stored:

 #config.yml
 result_dir: 'c:result'

So when you run rake test:acceptance the tables with the results will be stored as .html files in that directory.

This can be useful especially for continous integration.

Read more on: OpenQA project page.

Related posts:

1. Three Ways You Can Speed Up Your Fresh Rails Development A Ruby on Rails web application I’ve been developing...

Related posts brought to you by Yet Another Related Posts Plugin.

The Statemachine library is a simple yet full-featured Finite Statemachine framework. Define your statemachine in Ruby code and execute it in your system.

A statemachine keeps track of the status(state) of an application or device and responds to different inputs, which alter the state of the machine.

We have identified 3 fundamental components to a statemachine: States, Transitions, and Events.

• State: This is the status of the device or application the statemachine is being used for. At any given time, the statemachine is in one of its predefined states.
• Transition: Moving from one state to another is called a transition. Transitions are invoked by Events.
• Event: Events are the inputs to a statemachine.

This is a simple statemachine showing use of states and transitions.

Each transition can be defined by identifying the state where it begins, the event by which is invoked, and the state where it ends.Using this scheme we can define out vending machine like so…

Origin State	Event	Destination State
Waiting	dollar	Paid
Paid	selection	Waiting
Waiting	selection	Waiting
Paid	dollar	Paid

Defining it in ruby is not much harder:

require 'rubygems'
require 'statemachine'

vending_machine = Statemachine.build do
  trans :waiting, :dollar, :paid
  trans :paid, :selection, :waiting
  trans :waiting, :selection, :waiting
  trans :paid, :dollar, :paid
end

Actions allow statemachines to perform operations at various point during execution. There are two models for incorporating actions into statemachines.

• Mealy: A Mealy machine performs actions on transitions. Each transition in a statemachine may invoke a unique action.
• Moore: A Moore machine performs actions when entering a state. Each state may have it’s own entry action.

Mealy and Moore machines each have advantages and disadvantages. But one great advantage of both it that they are not mutually exclusive. If we use both models, and toss in some exit actions, we’ve got it made!

Oftentimes duplication can arise within a statemachine. One way to solve this problem is through the use of superstates. A superstate is a state that contains other states. One statemachine may have multiple superstates. And every superstate may contain other superstates. Superstates can be nested.But, one problem with superstates is that they may not know which state to return to when coming into that state. To solve this problem, superstates come with the history state.

More detailed download and installation instructions are available on Statemachine library project page.

Update: An insightful reader, Justin Jones, suggests an alternative: acts_as_state_machine plugin. Read more on Aizatto’s and Practical Ruby.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

microformats has been only two years old, yet it has brought significant changes in a relatively short time.

What is it, actually? According to microformats.org, “[microformats is] designed for humans first and machines second, [they] are a set of simple, open data formats built upon existing and widely adopted standards.”

Enough with the fluff, let’s see how it actually works, microformats in action:

Flickr picture source

The above picture is me browsing to the LinkedIn profile of one of Indonesia’s renowned Ruby on Rails experts, Arie Kusuma Atmaja. The overlay window that contains these semantic information is not a LinkedIn feature. Rather, it is the easily usable, cross-browser Microformats Bookmarklet by LeftLogic. Go on… try it if you haven’t!

As you can see, the mere act of clicking the bookmarklet shows you some important facts about Arie (or any microformats-enabled you’re currently at). In case of a microformats-enabled resume page like in LinkedIn, it shows you where he works, when, education information, and related stuff. For fun comparison purposes only, my LinkedIn profile has more detailed information than his, hehe

The best part is not only that the information is human-readable, but it can also be extracted and processed automatically by machines or software. The primary distinguishing trait of a microformats-enabled HTML page is that it has semantic meaning. A microformats processor can know the difference between a name, an e-mail address, a street address, a job, a university, and so on; while in plain HTML, all you can infer are things dealing with paragraphs, tables, lists, and so on.

Making microformats-enabled pages aren’t hard at all, actually it is very easy! It’s even much easier than CSS.

To see how simple it is, let’s see a snippet of a real-world microformats, still courtesy of Arie:

<div id="masthead" class="vcard contact">
  <div id="nameplate">
    <h1 id="name"><span class="fn n"> <span class="given-name">Arie</span> <span class="family-name">Kusuma Atmaja</span> </span></h1>
      <p class="headline title"><strong>Senior Ruby Developer at IMT</strong></p>
    <div class="adr">
      <p class="locality">Indonesia</p>
    </div>
  </div>
</div>

Most of the above snippet is just HTML. The microformats part is simply the class=”something“ convention. Simple, and it gets the job done.

Some more commonly used microformats specifications include:

• hCard for people and organizations
• hCalendar for calendars and Events
• hCalendar for calendars and Events
• VoteLinks and hReview for opinions, ratings, and reviews
• XFN for social networks
• rel-license for licenses
• rel-tag for tags, keywords, and categories
• XOXO for lists and outlines
• …and more…

Despite all these specifications, “who uses it?” is a good question. It turns out, there has been many, and more and more sites are adopting it. LinkedIn with hResume is one example, along with Google Maps, Yahoo, Flickr, and all these cool guys have been using them. Why shouldn’t you?

Interested? Here are some stuff to get you started:

1. Online Tools
   1. Microformats Bookmarklet by LeftLogic
      A handy microformats explorer bookmarklet. Useful also if you’re on the go and you want to check out some microformats. No need to install anything fancy on the computer.
   2. Operator Firefox Extension
      Microformats explorer extension for Firefox. Whether you’re a web developer or simply want to check out this latest technology, this is a very useful tool.
   3. Tails Firefox extension is another microformats Firefox extension
   4. Almost Universal Microformats Parser is a useful web-based tool to parse microformats.
2. Tutorials and Resources
   
   1. Microformats, what they are and how to use them, by Smashing Magazine
   2. Microformats Tutorial by XFront
      This is a very extensive tutorial. The complete tutorial package including the example files is a 13 MB download!
   3. How to Use Microformats by Vitamin Features
   4. Introduction to Microformats by WhyMicroformats.com
   5. The Big Picture on Microformats by Digital Web Magazine
   6. Another by Digital Web Magazine: Microformats Primer
   7. Back to the future: Mozilla Firefox 3.0 Does Microformats
      Read/WriteWeb’s articles also touched microformats-related stuff quite often.
3. Microformat Parsers
   1. Mofo Ruby Gem and Rails Plugin
      Of course, this is Ruby on Rails blog! Mofo is a microformats parser for Ruby and it also doubles as a Rails plugin. Check out Chris Wanstrath’s post for more information.
      There are also microformat parsers for other languages:
   2. Sumo is a microformats parser for JavaScript
   3. hKit is a microformats parser for PHP
   4. Microformats Parser is another parser for PHP
   5. Microformats Parser for Python
   6. Hpricot Ruby Gem
      Found a bizarre microformat or inventing your own? No problem, Hpricot comes to the rescue. Parse any HTML-ish document as you see fit… More info available from this RedHanded post.
   7. scrAPI is another Ruby library for parsing HTML that can be useful for processing microformats.
4. References
   1. Microformats.org
      “Official” web site of Microformats. You can read everything about microformats, current specifications and newly proposed specs.
   2. “Microformats: Empowering Your Markup for Web 2.0″ Book by John Allsopp
      <br />
      This is the first book dedicated to, and is a comprehensive guide to, microformats. It explores why, in Bill Gates’s words, “We need microformats”; how microformats work; and the kinds of problems microformats help solve. the book covers every current microformat, with complete details of the syntax, semantics, and uses of each, along with real-world examples and a comprehensive survey of the tools available for working with them. the book also features case studies detailing how major web content publishers such as yahoo put microformats to work in their web applications.
   3. Brian Suda’s microformats cheatsheet
      For people who likes it quick and done, this is perfect. It lists microformats properties by format and also lists each format and the hierarchy. This includes elemental microformats, compound microformats and some of the standard design patterns used.
   4. Dave Child’s microformats cheatsheet is another good reference
   5. And more cheatsheets on microformats.org wiki
   6. Gleaning Resource Descriptions from Dialects of Languages (GRDDL) is a recently approved W3C Recommendation that can be used, among others, for extracting semantic information (including microformats) from HTML pages.
   7. microformatique. A blog about all things microformats!

Feel free to add more resources as you see fit, in the comments!

Updates:

1. I originally thought I was gonna list 10 resources… But it seems there are much more
2. More links to John Allsopp’s resources

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Tau gak twitter tuh punya API

Ini contoh penggunaannya:

ceefour@ojalanow:~/bin$ salsabeela 'untuk sekarang enak gini'
Sending salsabeela 'untuk sekarang enak gini' '.... OK!
ceefour@ojalanow:~/bin$ salsabeela 'gak perlu mandi tiap hari '
Sending salsabeela 'gak perlu mandi tiap hari '.... OK!
ceefour@ojalanow:~/bin$ cat salsabeela
#!/usr/bin/ruby
require "#{File.dirname(__FILE__)}/twitter_pm"
send_pm 'salsabeela', ARGV.join(' ')

isi twitter_pm.rb :

ceefour@ojalanow:~/bin$ cat twitter_pm.rb
require 'rubygems'
gem 'twitter4r', '>=0.2.0'
require 'twitter'

def send_pm(recipient_id, message)
t = Twitter::Client.new(:login => 'gauldong@gmail.com', :password => ****************)
message = ARGV.join(' ')
sent = false
begin
recipient = t.user(recipient_id)
rescue
raise("Cannot find user #{recipient_username}")
end
print "Sending #{recipient.screen_name} '#{message}'"
$stdout.flush
sending = Thread.new { t.message(:post, message, recipient); sent= true; }
status = Thread.new { until sent; print '.'; sleep(0.5); $stdout.flush; end }
sending.join
status.join
puts ' OK!'
end

ato gini :

ceefour@ojalanow:~/bin$ irb -rubygems
irb(main):001:0> gem 'twitter4r'
=> true
irb(main):002:0> require 'twitter'
=> true
irb(main):003:0> t = Twitter::Client.new(:login => 'gauldong@gmail.com', :password => ****************)
=> #<Twitter::Client:0xb773d658 @login="gauldong@gmail.com", @password=****************>
irb(main):004:0> ollie = t.user('salsabeela')
=> #<Twitter::User:0xb7738090 @protected=false, @id=7296272, @profile_image_url="http://assets2.twitter.com/system/user/profile_image/7296272/normal/profileollie.jpg?1183741074", @client=#<Twitter::Client:0xb773d658 @login="gauldong@gmail.com", @password=****************>, @screen_name="salsabeela", @description="What I learn today...", @url="http://blog.salsabeela.com", @location="Jakarta", @name="Ollie">
irb(main):013:0* for f in ollie.friends; puts f.screen_name; end
popurls
al3x
davewiner
bbcnews
detikcom
ceefour
confession
21c
hotdogsladies
OpinionJournal
cnnbrk
avianto
thomasarie
jenniesbev
twittown
notstevenwright
farry
dhewlett
mbot
kukuhtw
BarackObama
jafrane
javajive
budip
istribawel
enda
timer
Indonesia
unwinged

lucu kan? =))

thanks to Susan Potter for making twitter4r gem

PS: Twitter tuh apaan sich?!?!? =))

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.