sorted by: recent | see : popular

Content Tagged with tricks + Elsewhere

Never one to let us down on the ingenuity front, Why The Lucky Stiff (author of the Poignant Guide and creator of Shoes) is busy working on a system that can convert Ruby 1.9 bytecode to Python bytecode (and from there into regular Python by way of Python’s decompilation facilities). It’s exactly the sort of thing that could take off with more eyes looking at it, and Why has made it available on GitHub. This technique isn’t likely to unite Python and Ruby in any deep and meaningful way (to the point of a shared interpreter), but the research and experiments involved are worth a try.

Ruby is an incredibly easy language to learn, but it’s still often necessary to look up something we’ve forgotten. Often this can be done by using Google or using any Ruby books we have on our shelves, but sometimes it’s handy to refer to a simpler set of notes, such as a “cheat sheet.” Quite a few Ruby developers have made cheat sheets for Ruby, and this post attempts to cover the most interesting ones.

The idea for this initial list (Don’t worry, Rails will be covered later on) came from Scott Klarr’s own list. Scott has been quite prolific lately in putting together lists of cheat sheets. Some of his lists are: Apache cheat sheets, MySQL cheat sheets, PHP cheat sheets, and JavaScript / AJAX cheat sheets.

But.. on with the Ruby cheat sheets:

Ruby Cheatsheet (PDF and PNG)

Ruby QuickRef (HTML)

Ruby Reference (PDF)

Cheat: Ruby Cheat Sheets on your Terminal! (Application)

A Beginner’s Notes (HTML)

Ruby Command Line Parameters Cheat Sheet (HTML)

Strftime Parameters (HTML)

In the first of a series, Andrea Wright looks at how to create games using Ruby. The series isn't a tutorial level set of articles, but instead a walk through some of the major libraries and technologies you can use along with some code examples. In this first edition, Andrea looks at Ruby/SDL, Rubygame (inspired heavily by PyGame, a significant Python game development library) and RUDL.

Just over a month ago I mentioned the release of "Shoes", a new Ruby library for creating "Web-like desktop apps" by Why The Lucky Stiff. Shoes provides a somewhat platform-independent way of creating desktop applications easily. Now that Shoes is several weeks old, it's worth pointing to a few resources and tutorials that will come in useful if you decide to start building Shoes-powered apps:

Running with Shoes - A Mini GUI Toolkit by Juixe: A great walkthrough building a simple Shoes application.

Cut Holes in Shoes and Get A Mask by Why The Lucky Stiff: A demonstration of using masks to create fancy text graphics.

Running with Shoes - 2D Graphics and Animation by Juixe: A look at drawing shapes in a Shoes app, such as lines, ovals, and rectangles, along with simple animation techniques.

Source code for a basic text editor by Why The Lucky Stiff: Source for a bare bones editing tool.

Yeah, Shoes Has Just a Few Simple Controls by Why The Lucky Stiff: A demonstration of a few of Shoes' widgets.

Mashing In Some Graphics by Why The Lucky Stiff: A code example of drawing rectangles within a Shoes application.

Hypershoes by Why The Lucky Stiff: A look at how to build a "book reader" program in Shoes and how Shoes' concept of URLs helps.

Deplate is a Ruby-based tool written by Thomas Link to convert documents written in wiki-like markup to various output formats. Supported output formats include LaTeX, HTML, "HTML slides", DocBook (which means it can also convert to PDF, and other DocBook-supported output), and plain text.

In addition to being capable of reading various Wiki markup variants, a particularly interesting feature is it also handles rdoc input which is very handy for generating print-ready documentation of your Ruby projects.

To see the results for yourself, various samples of Deplate generated output are available for your viewing pleasure. To get it, you can download the stable version from Deplate project files page or check out its latest development version from CVS.

Matthew Bass has written a tutorial, published by InfoQ, called "Automating File Uploads with SSH and Ruby." It provides an in-depth look into building a small Ruby script that can backup files to a remote machine over SSH using the Net-SSH and Net-SFTP libraries. It goes into quite some depth, and provides source code for a recursive backup script. If you haven't had a dig into the Net-SSH and Net-SFTP libraries yet, it's worth a look to see how the basics work.

Handshake, currently in version 0.3.0, is an informal design-by-contract system written by Brian Guthrie in pure Ruby. It's intended to allow Ruby developers to apply simple, clear constraints to their methods and classes.

Handshake is definitely welcome alongside the ever-increasing number of test-driven and behavior-driven design/development based tools, such as RSpec and test/spec.

Some examples of Handshake contracts (from its documentation):

# An array that can never be empty.
class NonEmptyArray < Array
include Handshake    invariant { not empty? }
end

# An array to which only strings may be added.
class NonEmptyStringArray < NonEmptyArray
contract :initialize, [[ String ]] => anything
contract :<<, String => self
contract :+, many?(String) => self
contract :each, Block(String => anything) => self
end

Visit Handshake project page and Rdoc documentation for more information.

At MIX07 a few days ago, Microsoft announced "Silverlight", a new Flash-esque .NET-based platform for delivering "media experiences" and "rich interactive applications" on the Web. It's interesting, and some people seem to think it's going to revolutionize the Web, but that's not why we're interested in it at Ruby Inside.

The most interesting part of the Silverlight announcement is that it's based on a subset of the CLR (Common Language Runtime) from Microsoft's .NET platform. The .NET CLR has become a common target for programming language runtimes recently, but Microsoft has officially announced C#, Javascript, VB, Python and Ruby support for Silverlight's CLR. Microsoft are also adding new features in a system called the DLR (Dynamic Language Runtime) to bring more dynamic features (as required by Python and Ruby) to the CLR. InfoQ has more information on this, in terms of Ruby.

What all of this means is that there's baked-in support for Ruby in what could be one of the biggest runtime environments on the Web in the next few years, and this can only be a good thing for Ruby. Jon Udell sat down with John Lam (the creator of RubyCLR) and talked about the DLR, Ruby, and how the whole caboodle works / will work.

Let's cross our fingers and hope this isn't ActiveX all over again.

Ilya Grigorik has written a article demonstrating three different ways you can schedule tasks to run using Ruby, including a simple thread based scheduler, a OpwnWFEru based scheduler, and a BackgrounDRB based scheduler. A notable omission is RailsCron, which provides another alternative for Rails users.

I've stumbled across several great snippets of Ruby code on the Web in the past few weeks, and rather than bore you with a post on each one, here's a whole collection at once:

1. RSS Twitter Bot - A short Ruby script that will read an RSS feed and republish it to your Twitter account. This could be useful for livestreaming or getting some sort of commercial presence on there.

2. Check if a number is prime in ONE line of Ruby - A rather mind-boggling technique to detect primes using a regular expression (!)

3. iTunes Database Parser - A short script that reads through your iTunes database and tells you what you like to listen to based on your listening habits.

4. CSV to XML Converter - Short and sweet.

5. Send and receive SMS text messages with Ruby and a GSM modem - I'll admit.. I wrote this one, but it works. You may need to hack the SerialPort library to support your GSM modem, especially if it's not on a usual port. I had to hack the C a little for OS X using /dev/something-weird-here, etc. Hopefully this will get you going though.

6. to_fraction method for Float

7. Create Web site thumbnails quickly with Ruby - Another one of my mine I'm afraid, but again, it works well (so far)!

Evan Weaver had a basic problem to solve:

We need to compute whether a point lies within a polygon. And we need to do it a lot.

Due to MySQL's lacking geometry features, Evan had to perform location searches using Ruby code to find points within certain polygons. Keen for a speed-up, Evan digs out some C code from 1987 and sets about using RubyInline to speed up the whole process. The end result? A 22x increase of speed.

Of particular interest to RubyInline newbies will be the way Evan had to adjust the C code for it to work directly on Ruby objects.

For the past few months Peter Szinek has been giving me lots of tasty tidbits about his forthcoming ScRUBYt Web-scraping toolkit, and now it's finally fully released to the public! Peter describes ScRUBYt as "WWW::Mechanize and Hpricot on Steroids" and this description is pretty bang on.

As well as providing a simple DSL for performing Web actions (clicking links, submitting forms, etc.), one of ScRUBYt's most impressive features is that you can provide it with 'example' data from which it will extrapolate a search pattern and then find any other similar data within the same page. This is demonstrated perfectly by Peter's basic example:

ebay_data = Scrubyt::Extractor.define do
   fetch 'http://www.ebay.com/'
   fill_textfield 'satitle', 'ipod'
   submit
   click_link 'Apple iPod'

   record do
     item_name 'APPLE NEW IPOD MINI 6GB MP3 PLAYER SILVER'
     price '$71.99'
   end
   next_page 'Next >', :limit => 5
end

This code goes to ebay.com, looks for iPods, and then extracts all records using a dummy one as an example. It then proceeds through up to 5 more pages of records, returning them all as an XML dataset.

If this all floats your boat, there's a lot to explore. Start off with the official site and Peter's comprehensive announcement. Peter also has a lengthy tutorial available which makes good reading.

Russ Olsen has been putting together a small series of blog posts about building a DSL in Ruby. The first part dates from October 2006, but the second part has just been released, making it a good double length read. In the mini-series, Russ looks at the motivation for developing a DSL and develops a basic DSL called Potemkin.

Note: This story actually dates back from May 2006, but I don't remember hearing about it then, and it's tucked down inside Alexa's Developer's Corner.

Using the Alexa Web Search Platform as a source of data, Derrick Pallas put together a search engine using Ruby, RMagick and Amazon S3. With AWSP's data set and CPU cluster he fetched 5,000,000 photos from the Web, analyzed their EXIF info with RMagick , and uploaded them to Amazon S3. The result was Camera Image Search, a search engine that can show you pictures taken with certain cameras or with certain exposure times / focal lengths / etc (for some reason the Manufacturer drop down does not appear to work, but other fields do).

This is an impressive demonstration of using the CPU power and mammoth data sets provided by Alexa and Amazon to put together something that would otherwise be out of the reach of the independent developer, and getting the full instructions to how he did it is great too.

Jamis Buck has put together a cool series of articles about ActiveRecord's find method as used in Rails. He goes into a lot of detail about how find and its related methods work in terms of the internals of ActiveRecord. Jamis' explanations are not only useful for Rails developers, but for anyone interested in patterns and how to structure code in Ruby. The Rails team don't always do everything the 'best' way, but it's usually tight, well developed code you can learn a lot from.

In the first installment, Jamis just presents a basic introduction to his series.

In the second installment, he leaps right in to the details of find and its child methods, find_from_ids, find_every and find_initial. If you want to see how the find methods put together the correct SQL queries, it's a must read, and it takes away a lot of the 'mystery' of the black box that is ActiveRecord.

In the latest, third, installment, Jamis looks at dynamic finders (e.g. find_by_username_and_password and similar).

Hopefully Jamis will keep posting stuff like this because it makes fascinating reading.

Corban Brook presents a step-by-step guide to producing 'great looking collages' using Ruby and the RMagick graphics library. Rather than be stuck with a dry picture-by-picture view, Brook uses RMagick to great effect to produce a complex, dynamic image that looks as if it were put together by hand. If for nothing else, this is a great look at some reasonably advanced RMagick code and a great way to learn about a few of the more arcane methods it offers.

Rb-AppScript is an event bridge between Ruby and OS X that allows you to get AppleScript-esque control in OS X. The Appscript creators claim Appscript is a 'serious alternative' to AppleScript and it certainly looks good. Check out this example:

AS.app('TextEdit').documents[1].paragraphs[1].get

The equivalent AppleScript?

tell application "TextEdit"
    get paragraph 1 of document 1
end tell

Appscript provides the system to perform remote procedure calls to OS X applications, converts values between Ruby and Apple classes, and allows developers to get full use out of OS X while still using Ruby's object oriented environment.

Some user mail from Nathan Murray:

I just wanted to let you guys know I've just released the first version of my Backup Gem. You can read the manual here:
http://tech.natemurray.com/backup/

BackupGem aims to be the easiest and most flexible backup, archive and rotate tool. It’s a beginning-to-end solution for scheduled backups in a clean ruby package that is simple use and powerful when customized.

A configuration as simple as:

set :backup_path, "/var/local/backups/my_old_logs"
action :content, :is_contents_of => "/var/my_logs"

Will compress, encrypt, deliver, and rotate the contents of /var/my_logs. But this is just a taste of the power this gem has.

You can install the gem easily with gem install backup and the official documentation is very complete and full of examples. From what I can see so far, it's a very complete and flexible backup library that you can use to create your own backup systems with a minimum of fuss. Even better that it uses Ruby