While using Ruby for your projects, you may need some references.

These are some references that might help you in using Ruby:

• Language

General Syntax Rules

• Comments start with a pound/sharp (#) character and go to EOL.
• Ruby programs are sequence of expressions.
• Each expression is delimited by semicolons(;) or newlines unless obviously incomplete (e.g. trailing ‘+’).
• Backslashes at the end of line does not terminate expression.

Reserved words

alias   and     BEGIN   begin   break   case    class   def     defined
do      else    elsif   END     end     ensure  false   for     if
in      module  next    nil     not     or      redo    rescue  retry
return  self    super   then    true    undef   unless  until   when
while   yield

Type

Basic types are numbers, strings, ranges, regexen, symbols, arrays, and hashes. Also included are files because they are used so often.

Variables

$global_variable
@@class_variable
@instance_variable
[OtherClass::]CONSTANT
local_variable

• Standard Library

Ruby comes with an extensive library of classes and modules. Some are built-in, and some are part of the standard library. You can distinguish the two by the fact that the built-in classes are in fact, built-in. There are no dot-rb files for them.

Built-in Library

Class Hierarchy:

Object

• Hash
• Symbol
• IO
  • File
• Continuation
• File::Stat
• Data
• NilClass
• Exception (see tree above)
• Array
• Proc
• String

Standard Library

The essentials:

• • benchmark.rb a simple benchmarking utility
  • cgi-lib.rb decode CGI data – simpler than cgi.rb
  • cgi.rb CGI interaction
  • date.rb date object (compatible)
  • debug.rb ruby debugger
  • delegate.rb delegate messages to other object
  • English.rb access global variables by english names
  • fileutils.rb file utility methods for copying, moving, removing, etc.

• Tools: ruby(Command Line Options, Environment Variables), irb, xmp, ruby-mode, Debugger, rdoc

• Mindshare, Idiom and Patterns (Object Design, Other Third-party Libraries)

For further details visit Ruby Quick Reference page at ZenSpider.

No related posts.

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

Morph Labs is currently beta-testing their next-generation solution in application deployment, delivery, and management, the Morph Application Platform.

Acquiring hardware and configuring software to support web apps are things of the past. Morph Labs brings you the next-generation solution in application deployment, delivery, and management. Reduce your time to market and lower your startup costs no matter if you are an ISV, a developer or a business.

About Morph Labs

Morph Labs Inc. www.morphexchange.com is a Philippine-based Web 2.0 technology company focused on providing innovative technologies and applications to support Software as a Service (SaaS) globally.

Morph offers independent software vendors (ISVs), IT consulting organizations, application developers and entrepreneurs the quickest and simplest route to SaaS-enablement. Morph simplifies deployment and management of software as a service with an elastic Web 2.0 delivery and management solution — the Morph Application Platform.

Morph Application Platform, powered by Amazon EC2 grid computing technology, combines the elasticity in delivering and managing Web 2.0 applications and the simplicity of deploying software as a service (SaaS).

With no hardware to buy and no software to install and configure, Morph allows developers to easily grow or shrink their application environment on demand without disruption to the application. The Morph Application Platform is offered through a subscription to a Morph AppSpace, which is an instance of the Morph Application Platform.

Beyond delivery platforms and managed services, Morph will build simplified software applications (that run on our platform) that leverage open source technologies for small and medium businesses.

Morph’s first on-demand application is Morph helpME (released October 2007), provided via the software as a service model and runs on top of the Morph Application Platform. It’s an on-demand help and training system that enables sharing of knowledge while reducing overall cost and technical burden.

Morph helpME is a Ruby on Rails application running on the Morph Application Platform. It’s automatically formats, structures and creates menus, enabling faster deployment of new content.

If you are Ruby on Rails developers, bring your on-demand application to life with the Morph Application and leave the details to us!

Visit Morph home page to find out more!

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.

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.

Need to parse command line arguments for your Ruby program? OptiFlag comes to the rescue!

This image is shows a typical OptiFlag scenario. You will note that there is a natural indentation.

It’s really an easy way for getting command line in options into your program.

Rather than use the ‘module’ DSL syntax, we just re-use an existing class. Any method accessor will be used verbatim as a switch. OptiFlag will crawl up the inheritance hierarchy up to (but not including) object and use all accessors as standard ‘flag’s.

Let’s see the Example:

require 'optiflag'

# Title: SUPER EASY alternative method for getting command line options into your program.
# Description:  Rather than use the 'module' DSL syntax, we just re-use an existing class.  Any method accessor will be used verbatim as a switch.  OptiFlag will crawl up the inheritance hierarchy up to (but not including) object and use all accessors as standard 'flag's.
class Person
  attr_accessor  :name,:ssn
end
class Employee < Person
  attr_accessor  :username,:password
end

daniel = Employee.new

OptiFlag.using_object(daniel)

puts <<-EOF
     Name: #{ daniel.name}
 Password: #{ daniel.password}
 Username: #{ daniel.username}
      SSN: #{ daniel.ssn}
EOF

#h# ruby example_8.rb
#h# ruby example_8.rb -username doeklund -password AHA -ssn 1234562342 -name "Daniel Eklund"

For further details visit Optiflag Rubyforge project page.

No related posts.

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

Sinatra is a new cool open-source DSL-driven web application framework!

This super-sexy DSL runs at lighting speed. It sits on top of Mongrel and was written to be thread-safe, sleek and tiny. And an entire web-application can be written and contained in one file (or a small collection of files)!

It’s super easy to use! Let’s create an app from scratch to demonstrate!

Install!

gem install sinatra -y

Use!

• Create a file called lyrics.rb (or any name you like)
• Add

    require 'rubygems'
  
    require 'sinatra'

• Run (yes, with just ruby)

    % ruby lyrics.rb
  
    == Sinata has taken the stage on port 4567!

• Take a moment and view the default page localhost:4567. Go ahead and bask in it‘s glory.
• Notice:
  • It didn‘t create any page to show you that default page (just a cool thing to see, that‘s all)
  • There was nothing generated other than a log file
  • Sinatra is a really cool name for a web-framework that‘s a DSL
• Modify lyrics.rb by adding:

    get '/' do
  
      'Hello World'
  
    end

• Refresh (no need to restart Sinatra):

    http://localhost:4567

• Modify again (then refresh):

•   get '/' do
  
      <<-HTML
  
        <form action='/' method="POST">
  
          <input type="text" name="name" />
  
          <input type="submit" value="Say my name!" />
  
        </form>
  
      HTML
  
    end  post '/' do
  
      "Hello #{params[:name] || 'World'}!"
  
    end

• Now you try: Use the Sinatra::Erb::EventContext or Sinatra::Haml::EventContext to do the same. Do them inline and as template files.
• Learn more cool stuff: see Sinatra::Dsl
• Create your own plugins!
  1. Create a ‘vendor’ directory in your app directory
  2. Lay it out like: myapp.rb : root

        |- vendor
     
                     | - plugin_name
     
                   | - init.rb  # load and hook here
     
                   | - lib
     
                         |- modules/classes here

  3. Use it in your app!

For further details visit:

• http://sinatra.rubyforge.org/doc/
• http://www.xnot.org/sinatra
• http://del.icio.us/tag/sinatra

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.

NetBeans IDE 6.0 is, among other things, a Ruby and Rails text editor

The NetBeans IDE is a modular, standards-based, integrated development environment (IDE) written in the Java programming language. The NetBeans project consists of an open source IDE and an application platform, which can be used as a generic framework to build any kind of application.

The focus of NetBeans IDE 6.0 is improved developer productivity through a smarter, faster editor, and the integration of all NetBeans products into one IDE. Please download it, check it out and let us know what you think. The NetBeans IDE 6.0 is scheduled to be released in November 2007 (see roadmap).

Beta 1 was great. It’s even better now. I haven’t had any major issues in Beta 1 and I’m still trying to find what’s really “new” in Beta 2, but let’s say I think it will make you pretty satisfied.

Check out the code templates feature of NetBeans! Example: Simply type “:” (colon) then press Tab. I know, other Ruby editors (and IDEs) do this too, but it’s nice to see NetBeans have it too.

For further details:

• Download this cool IDE now
• Tons on mega-cool NetBeans + Ruby duo tips & tricks!
• Visit the NetBeans IDE 6.0 New & Noteworthy page

Related posts:

1. NetBeans IDE 6.8 Released — with Enhanced Ruby on Rails Support! NetBeans IDE version 6.8 has been released, Sun Microsystems’...

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

New Riders Press has recently launched a new web design book titled Bulletproof Web Design, authored by Dan Cederholm:

No matter how visually appealing or content-packed a Web site may be, if it’s not adaptable to a variety of situations and reaching the widest possible audience, it isn’t really succeeding. In Bulletproof Web Design, author and Web designer extraordinaire, Dan Cederholm outlines standards-based strategies for building designs that provide flexibility, readability, and user control–key components of every sucessful site. Each chapter starts out with an example of an unbulletproof site one that employs a traditional HTML-based approach which Dan then deconstructs, pointing out its limitations. He then gives the site a make-over using XHTML and Cascading Style Sheets (CSS), so you can see how to replace bloated code with lean markup and CSS for fast-loading sites that are accessible to all users. Finally, he covers several popular fluid and elastic-width layout techniques and pieces together all of the page components discussed in prior chapters into a single-page template.

More resources:

• Bulletproof Web Design at SimpleBits
• Review at haacked.com for the first edition of this book
• Bulleproof Web Design review at 456bereastreet.com

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.