smuby: simply - marvellous - ruby

PDF Seafood Sauce: Prawn

2008-07-30T14:58:21+01:00

PHOTO CREDIT: courtesy of leomm at sxc.hu

The Ruby community is privileged to have a number of very valuable utility libraries. One of these is the venerable PDF::Writer, which enables the production of .pdf files with Ruby methods. Unfortunately, PDF::Writer has performance issues that can make it excruciatingly slow. The time has come for new contenders to step into the Ruby PDF ring and one of the most promising is named Prawn.

This is what the Prawn project page says -

Prawn is a PDF writing library for Ruby. It aims to be fast, tiny, and nimble, like the majestic sea creature.

Prawn is a beneficiary of the Ruby Mendicant project and is being driven, to a large degree, by the needs of the Ruport reporting toolset which is looking for a credible alternative to its dependency on PDF::Writer. Progress is pretty swift with a GitHub repository aiding the development effort.

In a recent article, Gregory Brown provided this example of PDF::Writer code vs Prawn code

PDF::Writer

   1  
   2  pdf = PDF::Writer.new
   3  table = PDF::SimpleTable.new do |tab|
   4    tab.column_order.push(*%w(date rate))
   5    tab.columns["date"] = PDF::SimpleTable::Column.new("date") { |col|
   6      col.heading = "Date"
   7    }
   8    tab.columns["rate"] = PDF::SimpleTable::Column.new("rate") { |col|
   9      col.heading = "Rate"
  10    }
  11    tab.orientation   = :center
  12    data = csv_data.map do |e|
  13      { "date" => e[0], "rate" => e[1] }
  14    end
  15    tab.data.replace data
  16  end
  17  table.render_on(pdf)
  18  pdf.save_as('currency_pdf_writer.pdf')

same thing with Prawn

   1  
   2  Prawn::Document.generate("currency_prawn.pdf") do
   3    table csv_data, :font_size          => 10,
   4                    :vertical_padding   => 2,
   5                    :horizontal_padding => 5,
   6                    :position           => :center,
   7                    :row_colors         => :pdf_writer,
   8                    :headers            => ["Date","Rate"]
   9  end

The Prawn-fu looks a lot sweeter to me and the improvement in performance with Prawn over PDF::Writer is commendable. Get your Git on and download the latest Prawn version to give it a try yourself. If the bleeding edge is not for you then a gem should be appearing in the near future.

Keep an eye on this one it’s hot!

Permalink | comments(View)

blog comments powered by Disqus

Swing with a JRuby Wrapper: Profligacy

2008-07-25T23:04:26+01:00

PHOTO CREDIT: courtesy of resignent at sxc.hu

I recently whined about the dearth of sophisticated GUI builders in the Rubyverse. I still think that there’s a gap in the market for a slick product with a visual interface builder that surpasses the current crop to exploit. On the other hand, if you just want to create modest GUI things with Ruby, maybe a drag n’ drop, wysiwyg IDE with extra code-completion sauce could be deemed a tad unnecessary.

A while ago I bookmarked a site whilst perusing the works of one Zed A. Shaw (the biological father of Mongrel). I forgot about it until casting my net into the Omniscient Online Ocean to trawl for Ruby GUI fish. What I snared was a reference to Profligacy, a JRuby library that helps you to put some soothing Ruby mojo into the Swing GUI building maelstrom.

I’ve really tried to enjoy creating desktop applications with Swing, sadly, I remain less than enthusiastic about drowning in a pool of unadulterated Java and Swing. I just find it intellectually painful. Swing reminds me of Cod Liver Oil; I know that it’s good stuff, but it tastes a whole lot more pleasant with orange flavouring. Profligacy is to Swing what orange flavouring is to Cod Liver Oil.

To use Profligacy you’re going to need -

Java 1.5+
JRuby
the Profligacy library (I recommend installing the gem via gem install profligacy)

Trying to convince you of the power of Profligacy with paragraphs of pushy prose probably would not prove particularly persuasive, so ’ere’s some code.

profello.rb – A Hello World program using Profligacy

   1  # profello.rb 
   2  require 'rubygems' 
   3  require 'profligacy/swing'
   4  require 'profligacy/lel'
   5  
   6  class TestWindow
   7    include_package 'javax.swing'
   8    include_package 'java.awt'
   9    include Profligacy
  10  
  11    def initialize
  12      ui = Swing::LEL.new JFrame, "[*lab][buttons]" do |c,i|
  13        c.lab = JLabel.new "Press A Button."
  14        c.lab.preferred_size = Dimension.new(300, 0)
  15  
  16        c.buttons = Swing::LEL.new JPanel, "[first | second]" do |d,j|
  17          d.first = JButton.new "First" 
  18          d.second = JButton.new "Second"
  19          j.first = { :action => proc {|t,e| c.lab.text = "Hello world!" } }
  20          j.second = { :action => proc {|t,e| c.lab.text = "Are you ready for some GUI Profligacy?" } }
  21        end.build :auto_create_container_gaps => false
  22      end
  23  
  24      ui.build(:args => "Hello World") do |c|
  25        c.location_relative_to = nil
  26        c.default_close_operation = JFrame::EXIT_ON_CLOSE
  27      end
  28    end
  29  end
  30  
  31  SwingUtilities.invoke_later proc { TestWindow.new }.to_runnable

Run it -

jruby profello.rb

screenshot from running profello.rb

I’m assuming that you installed the Profligacy gem. If you didn’t, then some minor amendments to the code above will probably be required.

Java + JRuby is a winning combination for cross-platform GUI creations. Profligacy eases the pain.

Zed, if you are ever in the U.K. near the badlands of Essex, there is a pint of warm British beer waiting for you.

Permalink | comments(View)

blog comments powered by Disqus

Ruby Report Templates: Documatic

2008-07-22T14:02:18+01:00

PHOTO CREDIT: courtesy of biewoef at sxc.hu

Report generation is a crucial part of many business applications and yet this part of the application development process is often treated like an ugly step-child. In the Ruby world, one project is well on the way to becoming the de facto standard on the not so glamorous reporting catwalk: Ruport.

Ruport is a great project and is undergoing substantial development in a push towards a 2.0 release. The thing is, sometimes you need to be able to visualise the report during the building process. Wouldn’t it be great if you had some sort of visual report building mechanism to help you as you sculpt your Ruport management information masterpieces? Well, you do have such a beast because Ruport has teamed up with the ‘template-driven formatter’, Documatic.

Install it like so -

sudo gem install documatic

Documatic allows you to create report templates in OpenOffice.org (or in my case NeoOffice) that are used in conjunction with Ruport to generate your reports. Ruby code is embedded in the template to specify the format of your data, then you simply tell Documatic which template to use and where you want the output to go.

screenshot of Documatic tutorial.odt template

excerpt from Documatic tutorial.rb

require 'rubygems'
require 'documatic'

# Let's make a trivial table.

data = Ruport::Data::Table.new( :column_names => %w(Name Phone),
                                :data =>
                                [
                                 ['Madchili Restaurant', '(02) 9805 1287'],
                                 ['Shiraz Restaurant', '(02) 9858 2004'],
                                 ['The Ranch Bistro Grill', '(02) 9887 2411'],
                                ])

# Now let's generate an OpenDocument text file using Documatic.
# (Note: the output directory will be created if it does not exist
# yet.  If the output file already exists it will be overwritten.)

data.to_odt_template(:template_file => 'tutorial.odt',
                     :output_file   => 'output/tutorial.odt')

screenshot of output from Documatic tutorial.rb

Just in case you are worried about having to deploy OpenOffice.org with your apps, don’t be. OpenOffice.org is only required to create the templates, not to perform the generation, so the templates are deployed as standalone files.

This strikes me as a significant addition to Ruport’s capabilities that can only help to attract new users. Reporting could almost be getting sexy.

Permalink | comments(View)

blog comments powered by Disqus

State of the Ruby Nation: VM Choices

2008-07-20T11:46:53+01:00

PHOTO CREDIT: courtesy of Maffu at sxc.hu

I have a concern that’s been niggling away at the back of my mind that I’d like to share with you. What’s concerning me is the state of the Ruby nation in respect of VMs (virtual machines). If I’m going to run Ruby I need something that understands my Ruby code and translates it so that my instructions get acted upon. That’s the job of a Ruby VM.

At the moment, I really don’t have too many choices of Ruby VM for serious, production quality endeavour. If I play for team Java, then I’m looking at JRuby. If Java isn’t involved, then I’m looking at some variant of Ruby 1.8 (MRI) depending on vulnerability issues. In the future this is not going to be the case.

There are new kids appearing on the block, the most prominent of which seem to be: MRI + YARV, Rubinius and IronRuby (a.k.a Ruby.NET). I’m not including JRuby in this list because I consider it to be an established player.

Let me make something quite clear before I continue. I am not looking at this from the perspective of a developer. As a developer I like choices and I revel in new challenges. However, if I am the Chief Technical Officer (CTO) of a corporation, my priorities are going to be different. I’m going to have to make sound decisions that are good for the business and I’m going to have to justify those decisions in order to get the hard cash needed to implement them. Above all, I’m going to make decisions that, hopefully, won’t get me fired. It is with my CTO hat on that I address the Ruby VM issue.

The three VM implementations that I listed above are in development, but are making fairly rapid progress. When they are ready for prime time what am I going to choose?

Will I choose the new and improved MRI with added YARV, developed by members of the original Ruby (MRI) team? Or will I choose Rubinius backed by the prodigious talents at Engine Yard? Or will I go for IronRuby if I’m in a .NET shop? Maybe something else will be vying for my attention and I’ll plump for that.

Truth is, it doesn’t matter does it? I think that what matters is that Ruby code runs as expected regardless of VM. If the respective creators of Ruby VMs continue to work with that idea in mind everything will be rosy in the Ruby garden. If it gets to the point where I can’t run my code reliably on any one of the major Ruby VMs, then there is going to be some significant turbulence in the Rubyverse.

As a CTO, I want to know that systems can be written to do what was intended within budget and on time. With competent development teams and practicable methods, the Ruby language should enable me to achieve those goals more often than not. If things go wrong, I want to be able to call upon someone to fix them if the answers can’t be found in-house. I do not want to have to swap one Ruby VM for another, because anytime I need to do that, Ruby is off the language menu.

Permalink | comments(View)

blog comments powered by Disqus

Ruby GUI Goodness: Missing

2008-07-12T23:35:40+01:00

PHOTO CREDIT: courtesy of lusi at sxc.hu

I am not a happy badger. My mission was to unearth a tantalising Ruby GUI construction kit; devastatingly simple to set up and use, cross-platform, and did I mention, easy to set up and use. Well, I failed to find such a beast roaming the Rubyverse and I’m turning to you, my fellow Rubyistas, for inspiration.

The list of GUI prescriptions that I have tried are: Shoes, RubyCocoa, WxRuby, FXRuby, QtRuby and Monkeybars. I had fun trying them, but unfortunately they all left me with the feeling that there is still a vacancy for a Chief Fabricator to be filled in the Ruby GUI Construction department.

All of the projects listed have to be commended for their ingenuity. I had high hopes for Shoes (and still do), although I have not been able to get the latest Mac OSX ppc releases to run at all; the earlier ones having been partially functional on my platform.

RubyCocoa is targeted squarely at the Apple orchard, thus it fails to satisfy the cross-platform criterion. Nevertheless, it did introduce me to the impressive XCode Interface Builder so I’m not ungrateful.

WxRuby, FXRuby and QtRuby all fall at the twin hurdles of set up and/or ease of use. I’ve designed GUI applications with things like Powerbuilder from Sybase, and for me, drag n’ drop is king. While IDEs do exist for the aforementioned Ruby applications, they lack polish, and simplicity is not something that was paramount in their design as far as I can see. FXRuby interfaces, though cross-platform in nature, suffer from the additional handicap of looking uniformly ugly on all platforms.

Monkeybars falls into the same category as RubyCocoa for me. It is a worthy effort that strays into the Java world to make use of JRuby and IDEs like Netbeans. As with RubyCocoa, the development process seemed disjointed because it relies on the co-operation of disparate parts.

My quest began because I was curious to find out whether the Ruby GUI creator was, like the Sasquatch (a.k.a Bigfoot), the stuff of myth. I found that Ruby GUI builders do exist, though none can count me as a willing suitor – at the moment.

Permalink | comments(View)

blog comments powered by Disqus

Syntax Reminders: cheat

2008-07-11T17:51:02+01:00

PHOTO CREDIT: courtesy of eurok at sxc.hu

How many times have you racked your brain to try to remember some long lost fragment of syntax? You’ve got ‘man’ and ‘gem server’ to crank up at the console, but no, they’re just not immediate enough; they kinda stop you in mid flow. What you could do with, at times like that, is the equivalent of the person offstage at the theatre who prompts the actors when they forget their lines.

As if by magic, the consistently creative err.the_blog guys have read your mind. They have fashioned a commandline-driven cheat sheet utility, appropriately named cheat.

Just install in the time-honoured fashion -

sudo gem install cheat

Then take her for a spin. I’m always forgetting some Textile snippet or other -

chrisduncan:~$cheat textile
textile:
  Quick block modifiers:
    Header: hn.
    Blockquote: bq.
    Footnote: fnn.
    Numeric list: #
    Bulleted list: *
  
  Quick phrase modifiers:
    _emphasis_
    *strong*
    ??citation??
    -deleted text-
    +inserted text+
    ^superscript^
    ~subscript~
    %span%
  
  To apply attributes:
    (class)
    (#id)
    {style}
    [language]
  
  To align blocks:
    < right
    > left
    = center
    <> justify
  
  To insert a table:
    |a|table|row|
    |a|table|row|
  
  To insert a link:
    "linktext":url
  
  To insert an image:
    !imageurl!
  
  To define an acronym:
    ABC(Always Be Closing)
  
  To reference a footnote:
    [n]

Of course, if there isn’t a cheat sheet for your particular missing nugget of knowledge, you can always do some research elsewhere and manufacture a sheet for future use.

My advice to you is: if in doubt, cheat.

Permalink | comments(View)

blog comments powered by Disqus

Static is Still Cool: Webby

2008-07-11T00:03:50+01:00

PHOTO CREDIT: courtesy of svilen001 at sxc.hu

I’ve played with dynamic, database-driven web frameworks in order to create my blogs in the past and they were interesting projects to learn from. However, one thought kept nagging at me as I was carving my code – Is this overkill for a blog? The answer was a resounding yes. My blogging needs are really quite simple, much more suited to the calmer waters frequented by static website aficionados.

It is within those tranquil waters that the fantabulous Webby resides. In case you haven’t heard about Webby, it’s a ‘website management system’ that allows you to generate web pages from text-based templates. If you can handle the command line and utter the phrase – I don’ need no steenkin’ GUI! – on a regular basis like a rather poor stereotype from a Spaghetti Western, Webby could well become one of your Ruby weapons of choice.

A blog is basically a collection of static web pages. Once a post is written, it generally remains untouched. There may be the occasional tweak, but usually a post ain’t gonna change much if at all. There seems to be a temptation to fill a blog with numerous unwarranted bells and whistles in a vain attempt to encourage readership.

Does a blog really need a search capability? I’m yet to be convinced. Usually, my blog visits are the result of a Google search and once there, I might even be tempted to click on a few additional links. I don’t actually remember ever using a blog search box except to test if the ones that I created were working.

Tag clouds are popular, nevertheless, do they really add to the blog reading experience or are they just another web developer affectation?

Webby lets me publish on the web with the minimum of fuss and bother. I can use Textile, Markdown and Haml in my pages along with trusty ERB. I can customise and automate to my heart’s content, even including some javascript like the Disqus comment service in this site.

If you’re feeling the static vibe but Webby just doesn’t hit the spot, you might want to try these offerings on for size (they are in no particular order) -

My assertion is that static web pages are a good fit for blogging and yes, I think they’re still cool.

Permalink | comments(View)

blog comments powered by Disqus

Light Up Your Code: Ultraviolet

2008-07-06T23:56:35+01:00

PHOTO CREDIT: courtesy of nookiez at sxc.hu

I like the look of the output from the funky Ultraviolet syntax highlighting engine for code snippets in blogs, so I figured it was about time that I actually used it.

My blogging software of choice, Webby, comes with an Ultraviolet helper, consequently, I was feeling confident that I would be entering highlighting heaven without a struggle. I read the Webby reference material and saw that CSS files for the Ultraviolet themes (colour schemes) were required. Problem was that I didn’t see any mention of where these vital artefacts might be obtained.

Luckily, my good mate Google was able to supply a useful post from Yak Shavings (much obliged to you Phil Barnes) that allowed me to produce the CSS files for the standard Ultraviolet themes. After installing the gem with sudo gem install ultraviolet, I fired up irb and did the following -

irb(main):001:0> require 'uv'
=> true
irb(main):002:0> Uv.copy_files "xhtml", "css"
=> ["/opt/local/lib/ruby/gems/1.8/gems/ultraviolet-0.10.2/lib/.."]

Voila, a directory named ‘css’ containing the theme files appeared in my own ‘css’ directory that I had specified in the call to Uv.copy_files above. Magnifique.

I subsequently found that Ultraviolet has a command line utility after looking at the ‘usage’ page of the web site. If you type uv —help at the terminal/console you will get a helpful list of commands. I used this one to achieve a similar result to my irb excursion above -

uv -s ruby --copy-files css

This command did not return of its own volition and required a Ctrl-C to terminate it on my system. Has anyone else experienced this? Nonetheless, the CSS files were generated correctly when I examined them.

Here’s a small example of Ultraviolet’s prowess -

sunburst theme

   1  # Find the missing Ultraviolet CSS files
   2  def google_search(string)
   3    answer = Google(string)
   4    puts answer
   5  end

Ain’t it a thing of beauty?

Permalink | comments(View)

blog comments powered by Disqus

Regex Library Installation on OSX: Oniguruma

2008-07-05T23:21:21+01:00

PHOTO CREDIT: courtesy of crisderaud at sxc.hu

I’m running with Ruby 1.8.6 on Mac OSX 10.4.11 and normally that works well for me. However, I recently ran into a problem when I wanted to try out the highly attractive Ultraviolet syntax highlighter.

The command line invocation sudo gem install ultraviolet just choked horribly and spat out errors. Something was up with the Oniguruma regular expression library gem that Ultraviolet depends on and I needed to find out what, and, more importantly, what on earth the remedy was.

I googled, googled some more, and then decided to give up because the solutions that I found seemed either too complex or didn’t apply to my setup. I settled for Coderay instead, but my failure with Ultraviolet was bugging me.

Yesterday, I resumed the search for an answer to my Oniguruma conundrum. Good God almighty! An answer leapt from my Google search like an overeager salmon. The article that saved my sanity was this – thank you ‘Goodbye Helicopter’.

Anyway, in case there are others out there who are struggling to see the light with this problem, I figure that this information needs to be published as widely as possible, so here’s what to do.

Download the Oniguruma ‘C’ code tarball from this site. I used version 5.9.1
‘cd’ to the directory that you downloaded the tarball into and expand it.
‘cd’ to the extracted directory, in my case onig-5.9.1
Configure it with the command ./configure —prefix=/usr/local. The prefix path is where you would like to install the software. Change it to suit yourself if you need to.
Issue the command sudo make
Issue the command sudo make install

After this you should be able to install your Oniguruma-dependent gems with the greatest of ease. I hope these instructions work as well for you as they did for me.

Permalink | comments(View)

blog comments powered by Disqus

Rake + Sake: Thor

2008-07-03T17:58:33+01:00

PHOTO CREDIT: courtesy of vierdrie at sxc.hu

Thor is a Ruby scripting framework fresh from the fevered imagination of Yehuda Katz. It allows you to do all of the things that Rake and Sake have become popular for, with the added bonus of letting you write it all in regular Ruby syntax.

Let me show you what I mean. First install the Thor gem -

sudo gem install thor

Here is a Thor script that let’s me open Ruby gem directories in TextMate; something that I find myself doing quite often.

gemate.thor

 1 # module: gemate
 2 
 3 class Gemate < Thor
 4   
 5   desc "view NAME", "view gem directory in TextMate"
 6   def view(name)
 7   
 8     term = name + '*'
 9 
10     puts "Searching for '" + term + "'..."
11 
12     # get the path to the gem directory from rubygems and search for any matching directories
13     path = `gem env gemdir`
14     new_path = File.join([path.chomp, 'gems'])
15     Dir.chdir(new_path)
16     @d_arr = Dir.glob(term)
17 
18     if @d_arr.empty?
19       puts "Sorry, nothing like that found"
20     elsif @d_arr.size == 1
21       view_one()
22     else
23       view_list()
24     end
25   end
26     
27   private
28   
29     def view_one
30       puts @d_arr.first
31       print 'Do you want to view this? [Y/n]: '
32       resp = gets.chomp!
33       if resp.empty? or resp.downcase == 'y'
34         exec "mate #{@d_arr.first}"
35       end
36     end
37     
38     def view_list
39       @d_arr.each_with_index {|d,i| puts "#{i + 1}: #{d}"}
40       puts
41       print 'Choose a directory or quit(q): '
42       idx = gets.chomp!
43       if idx.downcase == 'q'
44         exit
45       elsif (1..@d_arr.size).include?(idx.to_i)
46         exec "mate #{@d_arr.at(idx.to_i - 1)}"
47       else
48         puts 'not a valid option'
49       end
50     end
51 
52 end

I invoke the script like this -

thor gemate:view GEM_NAME

Yehuda wrote a blog post that introduces Thor and provides a brief explanation of some of it’s features. There is also a GitHub repository that you can take a peek at if you’re interested enough.

The Force is strong with this one …

Permalink | comments(View)

blog comments powered by Disqus

Ruby for Kids: Hackety Hack

2008-06-24T20:15:31+01:00

I decided to introduce our 11-year old daughter to Ruby today, but I wanted to do it in a kid-friendly way, rather than a crusty, adulty way. So, who else in the Ruby firmament does a body turn to when in need of coding entertainment – you guessed it – why the lucky stiff and his hacktastic Hackety Hack.

Hackety is a Ruby coding environment aimed at kids of all ages. It has cartoons, an interactive tutorial, help pages and other things, all wrapped up in language pitched at your youngster. You can download it for Windows (XP, Vista) and Linux at the moment; a Mac OSX version is in the works.

This is a great resource and a fun introduction to the world of programming with Ruby. Let your kids loose with it and see what they create. It certainly put a smile on my daughter’s face.

Permalink | comments(View)

blog comments powered by Disqus

Shiny New Ruby Unix Shell: rush

2008-06-17T22:47:55+01:00

PHOTO CREDIT: courtesy of Ale Paiva at sxc.hu

rush is an ambitious attempt, by Adam Wiggins, to bring some Ruby flavour to the venerable Unix shell.

The idea is that you can use your beloved Ruby syntax in the rush shell to do those command line tasks that hitherto have been the province of Bash and siblings. Additionally, rush is intended as a way to administer remote machines.

An example from the rush website

local = Rush::Box.new('localhost')
remote = Rush::Box.new('my.remote.server.com')
local_dir = local['/Users/adam/myproj/']
remote_dir = remote['/home/myproj/app/']

local_dir.copy_to remote_dir
remote_dir['**/.svn/'].each { |d| d.destroy }

rush is still a callow youth, but offers up some interesting possibilities in the shadowy world of the shell.

Permalink | comments(View)

blog comments powered by Disqus

Devilishly Simple Background Ruby: Daemons

2008-06-15T20:25:52+01:00

PHOTO CREDIT: courtesy of spekulator at sxc.hu

If you’re looking for a super simple way to daemonize a Ruby script then have a sneaky peek at Daemons.

This description from the site sums up what the deal is with Daemons -

Daemons provides an easy way to wrap existing ruby scripts (for example a self-written server) to be run as a daemon and to be controlled by simple start/stop/restart commands.

All you need do if you want a Ruby script to run in the background as a daemon, say my_app.rb, is to wrap a call to my_app.rb like this -

my_app_control.rb

 1 #!/usr/bin/env ruby
 2 
 3 # This is my_app_control.rb. It allows you to daemonize my_app.rb
 4 #
 5 # Usage: ruby my_app_control.rb [start|stop|restart]
 6 #
 7 
 8 require 'rubygems'
 9 require 'daemons'
10 
11 Daemons.run('my_app.rb')

If you enter this at the console -

ruby my_app_control.rb start

The script __my_app.rb__ will start in the background, and a pid file will be created containing the process id of your newly spawned task. Unfortunately, because of the way that Daemons works, it is not easy to get feedback by way of console messages with a puts or print call, but you do have the option to log output to a file.

There are some other ways in which Daemons can be utilised that are well documented on the site. Nice, neat, try it.

Permalink | comments(View)

blog comments powered by Disqus

Ruby Web Application Plumbing: Rack

2008-06-09T20:39:52+01:00

There has been a proliferation of Ruby web application frameworks in recent times and this is mainly due to one thing; Rack.

Rack is a “Ruby webserver interface” that provides the plumbing for a Ruby web application framework to communicate with a webserver via an adapter. HTTP requests and responses are routed to the appropriate destinations with various niceties, like Apache-style logging, taken care of by Rack.

If your needs are simple, and a framework would be overkill, just use Rack on its own and code any little extras yourself. Visit the site for a list of frameworks that use Rack as well as a list of supported web servers.

I cannot stress this enough – if you are considering building YARWF (Yet Another Ruby Web Framework, pronounced ‘Yar-woof’) you need to be looking at Rack. It contains a lot of the basic infrastructure to get you started and is rapidly becoming a de facto standard in this space, even though it is only at release 0.3 at the time of writing.

To give you an idea of why people are excited about what Rack brings to the party, install Rack -

sudo gem install rack

Next, put the following in a file with a .rb suffix and run it -

taken from yeahnah.org

1 %w(rubygems rack).each { |dep| require dep } 
2 app = lambda { |env| [200, {}, 'Hello World!'] } 
3 Rack::Handler::Mongrel.run(app, :Port => 3000)

Yes that’s right, a working web app in 3 – count them – 3 lines of code.

There is a whole new Internet town growing up, filled with web houses that Rack built.

Permalink | comments(View)